Grafik Render Sorunu

  • Konuyu açan Konuyu açan benjordi
  • Açılış Tarihi Açılış Tarihi
  • Yanıt Yanıt 1
  • Gösterim Gösterim 92
Durum
İçerik kilitlendiği için mesaj gönderimine kapatıldı.
benjordi

benjordi

MT Üye
MT Üye
Mesaj
162
Çözümler
9
Beğeni
229
Puan
734
Ticaret Puanı
0
Video da gördüğünüz gibi bir sorun var nasıl çözerim bir türlü halledemedim



​


ActorInstanceRender.cpp:
Genişlet Daralt Kopyala 
#include "StdAfx.h"
#include "../EterLib/StateManager.h"
#include "../GameLib/MapManager.h"
#include "ActorInstance.h"
#include "../UserInterface/PythonBackground.h"
#include "../EterLib/Camera.h"
#include "ItemData.h"
#include <random>

bool CActorInstance::ms_isDirLine = false;

bool CActorInstance::IsDirLine()
{
    return ms_isDirLine;
}

void CActorInstance::ShowDirectionLine(bool isVisible)
{
    ms_isDirLine = isVisible;
}

void CActorInstance::SetMaterialColor(DWORD dwColor)
{
    if (m_pkHorse)
        m_pkHorse->SetMaterialColor(dwColor);

    m_dwMtrlColor &= 0xff000000;
    m_dwMtrlColor |= (dwColor & 0x00ffffff);
}

void CActorInstance::SetMaterialAlpha(DWORD dwAlpha)
{
    m_dwMtrlAlpha = dwAlpha;
}

float timer = 0.0f;
void CActorInstance::OnRender()
{
    auto* FlyManager = CFlyingManager::InstancePtr();
    auto* MapManager = FlyManager->GetMapManagerPtr();
    auto& OutDoor = MapManager->GetMapOutdoorRef();

    const float EPSILON = 1e-5f;
    timer += 0.000000060f;

    if (timer > 10)
        timer = 0.0f;


    D3DMATERIAL8 kMtrl;
    STATEMANAGER.GetMaterial(&kMtrl);
    kMtrl.Diffuse = D3DXCOLOR(m_dwMtrlColor);

    STATEMANAGER.SetMaterial(&kMtrl);
    STATEMANAGER.SaveRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);

    if (FlyManager) {
        if (MapManager && MapManager->IsMapOutdoor() && MapManager->IsMapReady())
        {
            if (Frustum::Instance().shadowType != 3 && m_fAlphaValue == 1.0f)
            {

                //HRESULT hr = D3DXSaveTextureToFile("depth.png", D3DXIFF_PNG, m_lpCharacterShadowMapTexture, nullptr);
                CCamera* pCurrentCamera = CCameraManager::Instance().GetCurrentCamera();
                STATEMANAGER.SetRenderState(D3DRS_FOGENABLE, 0);

                STATEMANAGER.SetVertexShader(OutDoor.m_lpShadowMapVertexShaderMain);
                STATEMANAGER.SetPixelShader(OutDoor.m_lpShadowMapPixelShaderMain);

                float isPC = 0.0f;
                if (IsPC())
                {
                    isPC = 1.0f;
                }

                // Vertex shader constants ----
                // Transformation matrix
                D3DXMATRIX worldMat;
                //STATEMANAGER.GetTransform(D3DTS_WORLD, &worldMat);
                ms_lpd3dDevice->GetTransform(D3DTS_WORLD, &worldMat);
                D3DXMatrixTranspose(&worldMat, &worldMat);
                //D3DXMatrixIdentity(&worldMat);
                ms_lpd3dDevice->SetVertexShaderConstantF(0, (const float*)(&worldMat), 4);
                // View-Projection
                D3DXMATRIX viewProjMat, viewMat, projMat;
                ms_lpd3dDevice->GetTransform(D3DTS_VIEW, &viewMat);
                ms_lpd3dDevice->GetTransform(D3DTS_PROJECTION, &projMat);
                // Projection matrix is not w-friendly, so fog doesn't work properly
                ms_lpd3dDevice->SetRenderState(D3DRS_FOGENABLE, 0); // replaced with fog in the shader

                D3DXMatrixMultiplyTranspose(&viewProjMat, &viewMat, &projMat);
                ms_lpd3dDevice->SetVertexShaderConstantF(4, (const float*)(&viewProjMat), 4);
                // Light space
                ms_lpd3dDevice->SetVertexShaderConstantF(8, (const float*)(&OutDoor.m_MatLightViewProj), 4);

                STATEMANAGER.SetVertexShaderConstant(16, (const float*)(&OutDoor.m_MatLightViewProj2), 4);

                // Light ViewProj matrix (TODO)


                // Pixel shader constants ----
                //D3DXVECTOR4 diffuseMatColor = { 1.0f, 1.0f, 1.0f, 1.0f };
                D3DMATERIAL9 material;
                STATEMANAGER.GetMaterial(&material);
                D3DLIGHT8 light;
                STATEMANAGER.GetLight(0, &light);
                STATEMANAGER.SetPixelShaderConstant(0, &light.Diffuse, 1);
                STATEMANAGER.SetPixelShaderConstant(1, &OutDoor.current_v3SunPosition, 1);
                STATEMANAGER.SetPixelShaderConstant(2, &light.Diffuse, 1);

                D3DXVECTOR3 AmbientLight = { 0.7f, 0.7f, 0.7f };

                STATEMANAGER.SetPixelShaderConstant(3, &AmbientLight, 1);
                // Fog settings
                D3DVECTOR cameraPos = CCameraManager::instance().GetCurrentCamera()->GetEye();
                STATEMANAGER.SetPixelShaderConstant(4, &cameraPos, 1);
                D3DCOLOR fogColor;
                STATEMANAGER.GetRenderState(D3DRS_FOGCOLOR, &fogColor);
                D3DXCOLOR fogColorX(fogColor);
                STATEMANAGER.SetPixelShaderConstant(5, (float*)fogColorX, 1);
                D3DVECTOR fogProps;
                STATEMANAGER.GetRenderState(D3DRS_FOGSTART, (DWORD*)&fogProps.x);
                STATEMANAGER.GetRenderState(D3DRS_FOGEND, (DWORD*)&fogProps.y);
                STATEMANAGER.SetPixelShaderConstant(6, &fogProps, 1);

                STATEMANAGER.SetPixelShaderConstant(7, &material.Ambient, 1);
                float shiness;
                D3DXVECTOR3 specularLight;
                float reducePointLightIntensity = 4.0f;

                shiness = 169.0f;
                specularLight = { 10.5f, 10.5f, 10.5f };

                STATEMANAGER.SetPixelShaderConstant(8, &shiness, 1);
                STATEMANAGER.SetPixelShaderConstant(9, &specularLight, 1);

                float shadowOpacity = 75.0f;
                if (shadowOpacity < 40.0f)
                    shadowOpacity = 40.0f;

                STATEMANAGER.SetPixelShaderConstant(10, (int*)&shadowOpacity, 1);

                if (OutDoor.m_lpCharacterShadowMapTexture)
                    STATEMANAGER.SetTexture(2, OutDoor.m_lpCharacterShadowMapTexture);
                if (OutDoor.m_lpCharacterShadowMapTexture4)
                    STATEMANAGER.SetTexture(3, OutDoor.m_lpCharacterShadowMapTexture4);

                // Transform   
                STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
                STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT);
                STATEMANAGER.SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
                STATEMANAGER.SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);

                STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_MODULATE);
                STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);

            }
            else
            {
                STATEMANAGER.SaveRenderState(D3DRS_FOGENABLE, TRUE);
            }
        }
    }

    switch (m_iRenderMode)
    {
    case RENDER_MODE_NORMAL:
        BeginDiffuseRender();
        RenderWithOneTexture();
        EndDiffuseRender();
        BeginOpacityRender();
        BlendRenderWithOneTexture();
        EndOpacityRender();
        break;
    case RENDER_MODE_BLEND:
        if (m_fAlphaValue == 1.0f)
        {
            BeginDiffuseRender();
            RenderWithOneTexture();
            EndDiffuseRender();
            BeginOpacityRender();
            BlendRenderWithOneTexture();
            EndOpacityRender();
        }
        else if (m_fAlphaValue > 0.0f)
        {
            BeginBlendRender();
            RenderWithOneTexture();
            BlendRenderWithOneTexture();
            EndBlendRender();
        }
        break;
    case RENDER_MODE_ADD:
        BeginAddRender();
        RenderWithOneTexture();
        BlendRenderWithOneTexture();
        EndAddRender();
        break;
    case RENDER_MODE_MODULATE:
        BeginModulateRender();
        RenderWithOneTexture();
        BlendRenderWithOneTexture();
        EndModulateRender();
        break;
    }

    STATEMANAGER.RestoreRenderState(D3DRS_CULLMODE);

    if (FlyManager) {
        if (MapManager && MapManager->IsMapOutdoor() && MapManager->IsMapReady())
        {
            if (Frustum::Instance().shadowType != 3 && m_fAlphaValue == 1.0f)
            {
                ms_lpd3dDevice->SetVertexShader(nullptr);
                ms_lpd3dDevice->SetPixelShader(nullptr);
            }
            else
            {
                STATEMANAGER.RestoreRenderState(D3DRS_FOGENABLE);
            }
        }
    }

    kMtrl.Diffuse = D3DXCOLOR(0xffffffff);
    STATEMANAGER.SetMaterial(&kMtrl);

    if (ms_isDirLine)
    {
        D3DXVECTOR3 kD3DVt3Cur(m_x, m_y, m_z);

        D3DXVECTOR3 kD3DVt3LookDir(0.0f, -1.0f, 0.0f);
        D3DXMATRIX kD3DMatLook;
        D3DXMatrixRotationZ(&kD3DMatLook, D3DXToRadian(GetRotation()));
        D3DXVec3TransformCoord(&kD3DVt3LookDir, &kD3DVt3LookDir, &kD3DMatLook);
        D3DXVec3Scale(&kD3DVt3LookDir, &kD3DVt3LookDir, 200.0f);
        D3DXVec3Add(&kD3DVt3LookDir, &kD3DVt3LookDir, &kD3DVt3Cur);

        D3DXVECTOR3 kD3DVt3AdvDir(0.0f, -1.0f, 0.0f);
        D3DXMATRIX kD3DMatAdv;
        D3DXMatrixRotationZ(&kD3DMatAdv, D3DXToRadian(GetAdvancingRotation()));
        D3DXVec3TransformCoord(&kD3DVt3AdvDir, &kD3DVt3AdvDir, &kD3DMatAdv);
        D3DXVec3Scale(&kD3DVt3AdvDir, &kD3DVt3AdvDir, 200.0f);
        D3DXVec3Add(&kD3DVt3AdvDir, &kD3DVt3AdvDir, &kD3DVt3Cur);

        static CScreen s_kScreen;

        STATEMANAGER.SaveTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
        STATEMANAGER.SaveTextureStageState(0, D3DTSS_COLOROP, D3DTOP_DISABLE);
        STATEMANAGER.SaveTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
        STATEMANAGER.SaveRenderState(D3DRS_ZENABLE, FALSE);
        STATEMANAGER.SetRenderState(D3DRS_LIGHTING, TRUE);

        s_kScreen.SetDiffuseColor(1.0f, 1.0f, 0.0f);
        s_kScreen.RenderLine3d(kD3DVt3Cur.x, kD3DVt3Cur.y, kD3DVt3Cur.z, kD3DVt3AdvDir.x, kD3DVt3AdvDir.y, kD3DVt3AdvDir.z);

        s_kScreen.SetDiffuseColor(0.0f, 1.0f, 1.0f);
        s_kScreen.RenderLine3d(kD3DVt3Cur.x, kD3DVt3Cur.y, kD3DVt3Cur.z, kD3DVt3LookDir.x, kD3DVt3LookDir.y, kD3DVt3LookDir.z);

        STATEMANAGER.SetRenderState(D3DRS_LIGHTING, TRUE);
        STATEMANAGER.RestoreRenderState(D3DRS_ZENABLE);

        STATEMANAGER.RestoreTextureStageState(0, D3DTSS_COLORARG1);
        STATEMANAGER.RestoreTextureStageState(0, D3DTSS_COLOROP);
        STATEMANAGER.RestoreTextureStageState(0, D3DTSS_ALPHAOP);

#ifdef DIRECTX9
        STATEMANAGER.RestoreFVF();
#else
        STATEMANAGER.RestoreVertexShader();
#endif
    }
}

void CActorInstance::BeginDiffuseRender()
{
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);

    STATEMANAGER.SaveRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
}

void CActorInstance::EndDiffuseRender()
{
    STATEMANAGER.RestoreRenderState(D3DRS_ALPHABLENDENABLE);
}

void CActorInstance::BeginOpacityRender()
{
    STATEMANAGER.SaveRenderState(D3DRS_ALPHATESTENABLE, TRUE);
    STATEMANAGER.SaveRenderState(D3DRS_ALPHAREF, 0);
    STATEMANAGER.SaveRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);

    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
}

void CActorInstance::EndOpacityRender()
{
    STATEMANAGER.RestoreRenderState(D3DRS_ALPHATESTENABLE);
    STATEMANAGER.RestoreRenderState(D3DRS_ALPHAREF);
    STATEMANAGER.RestoreRenderState(D3DRS_ALPHAFUNC);
}

void CActorInstance::BeginBlendRender()
{
    STATEMANAGER.SaveRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
    STATEMANAGER.SaveRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
    STATEMANAGER.SaveRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);

    STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, D3DXCOLOR(1.0f, 1.0f, 1.0f, m_fAlphaValue));
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_TFACTOR);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
}

void CActorInstance::EndBlendRender()
{
    STATEMANAGER.RestoreRenderState(D3DRS_ALPHABLENDENABLE);
    STATEMANAGER.RestoreRenderState(D3DRS_SRCBLEND);
    STATEMANAGER.RestoreRenderState(D3DRS_DESTBLEND);
}

void CActorInstance::BeginAddRender()
{
    STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, m_AddColor);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);

    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_CURRENT);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_TFACTOR);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_ADD);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);

    STATEMANAGER.SaveRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
}

void CActorInstance::EndAddRender()
{
    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
    STATEMANAGER.RestoreRenderState(D3DRS_ALPHABLENDENABLE);
}

void CActorInstance::RestoreRenderMode()
{
    // NOTE : This is temporary code. I wanna convert this code to that restore the mode to
    // model's default setting which had has as like specular or normal. - [levites]
    m_iRenderMode = RENDER_MODE_NORMAL;
    if (m_kBlendAlpha.m_isBlending)
    {
        m_kBlendAlpha.m_iOldRenderMode = m_iRenderMode;
    }
}

void CActorInstance::SetAddRenderMode()
{
    m_iRenderMode = RENDER_MODE_ADD;
    if (m_kBlendAlpha.m_isBlending)
    {
        m_kBlendAlpha.m_iOldRenderMode = m_iRenderMode;
    }
}

void CActorInstance::SetRenderMode(int iRenderMode)
{
    m_iRenderMode = iRenderMode;
    if (m_kBlendAlpha.m_isBlending)
    {
        m_kBlendAlpha.m_iOldRenderMode = iRenderMode;
    }
}

void CActorInstance::SetAddColor(const D3DXCOLOR& c_rColor)
{
    m_AddColor = c_rColor;
    m_AddColor.a = 1.0f;
}

void CActorInstance::BeginModulateRender()
{
    STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, m_AddColor);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);

    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_CURRENT);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_TFACTOR);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_MODULATE);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);

    STATEMANAGER.SaveRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
}

void CActorInstance::EndModulateRender()
{
    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
    STATEMANAGER.RestoreRenderState(D3DRS_ALPHABLENDENABLE);
}

void CActorInstance::SetModulateRenderMode()
{
    m_iRenderMode = RENDER_MODE_MODULATE;
    if (m_kBlendAlpha.m_isBlending)
    {
        m_kBlendAlpha.m_iOldRenderMode = m_iRenderMode;
    }
}

void CActorInstance::RenderCollisionData()
{
    static CScreen s_Screen;

    STATEMANAGER.SetRenderState(D3DRS_LIGHTING, FALSE);
    STATEMANAGER.SaveRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    if (m_pAttributeInstance)
    {
        for (DWORD col = 0; col < GetCollisionInstanceCount(); ++col)
        {
            CBaseCollisionInstance* pInstance = GetCollisionInstanceData(col);
            pInstance->Render();
        }
    }

    STATEMANAGER.SetRenderState(D3DRS_ZENABLE, FALSE);
    s_Screen.SetColorOperation();
    s_Screen.SetDiffuseColor(1.0f, 0.0f, 0.0f);
    TCollisionPointInstanceList::iterator itor;
    /*
    itor = m_AttackingPointInstanceList.begin();
    for (; itor != m_AttackingPointInstanceList.end(); ++itor)
    {
        const TCollisionPointInstance& c_rInstance = *itor;
        for (DWORD i = 0; i < c_rInstance.SphereInstanceVector.size(); ++i)
        {
            const CDynamicSphereInstance& c_rSphereInstance = c_rInstance.SphereInstanceVector[i];
            s_Screen.RenderCircle3d(c_rSphereInstance.v3Position.x,
                c_rSphereInstance.v3Position.y,
                c_rSphereInstance.v3Position.z,
                c_rSphereInstance.fRadius);
        }
    }
    */
    s_Screen.SetDiffuseColor(1.0f, (isShow()) ? 1.0f : 0.0f, 0.0f);
    D3DXVECTOR3 center;
    float r;
    GetBoundingSphere(center, r);
    s_Screen.RenderCircle3d(center.x, center.y, center.z, r);

    s_Screen.SetDiffuseColor(0.0f, 0.0f, 1.0f);
    itor = m_DefendingPointInstanceList.begin();
    for (; itor != m_DefendingPointInstanceList.end(); ++itor)
    {
        const TCollisionPointInstance& c_rInstance = *itor;
        for (DWORD i = 0; i < c_rInstance.SphereInstanceVector.size(); ++i)
        {
            const CDynamicSphereInstance& c_rSphereInstance = c_rInstance.SphereInstanceVector[i];
            s_Screen.RenderCircle3d(c_rSphereInstance.v3Position.x,
                c_rSphereInstance.v3Position.y,
                c_rSphereInstance.v3Position.z,
                c_rSphereInstance.fRadius);
        }
    }

    s_Screen.SetDiffuseColor(0.0f, 1.0f, 0.0f);
    itor = m_BodyPointInstanceList.begin();
    for (; itor != m_BodyPointInstanceList.end(); ++itor)
    {
        const TCollisionPointInstance& c_rInstance = *itor;
        for (DWORD i = 0; i < c_rInstance.SphereInstanceVector.size(); ++i)
        {
            const CDynamicSphereInstance& c_rSphereInstance = c_rInstance.SphereInstanceVector[i];
            s_Screen.RenderCircle3d(c_rSphereInstance.v3Position.x,
                c_rSphereInstance.v3Position.y,
                c_rSphereInstance.v3Position.z,
                c_rSphereInstance.fRadius);
        }
    }

    s_Screen.SetDiffuseColor(1.0f, 0.0f, 0.0f);
    //if (m_SplashArea.fDisappearingTime > GetLocalTime())
    {
        CDynamicSphereInstanceVector::iterator itor = m_kSplashArea.SphereInstanceVector.begin();
        for (; itor != m_kSplashArea.SphereInstanceVector.end(); ++itor)
        {
            const CDynamicSphereInstance& c_rInstance = *itor;
            s_Screen.RenderCircle3d(c_rInstance.v3Position.x,
                c_rInstance.v3Position.y,
                c_rInstance.v3Position.z,
                c_rInstance.fRadius);
        }
    }

    STATEMANAGER.SetRenderState(D3DRS_ZENABLE, TRUE);
    STATEMANAGER.RestoreRenderState(D3DRS_CULLMODE);
    STATEMANAGER.SetRenderState(D3DRS_LIGHTING, TRUE);
}

void CActorInstance::RenderToShadowMap()
{
    if (m_fAlphaValue > 0.01)
    {
        CGraphicThingInstance::RenderToShadowMap();
    }

    if (m_pkHorse)
        m_pkHorse->RenderToShadowMap();
}


Material.cpp:
Genişlet Daralt Kopyala 
#include "StdAfx.h"
#include "Material.h"
#include "Mesh.h"
#include "../eterbase/Filename.h"
#include "../eterlib/ResourceManager.h"
#include "../eterlib/StateManager.h"
#include "../eterlib/GrpScreen.h"

CGraphicImageInstance CGrannyMaterial::ms_akSphereMapInstance[SPHEREMAP_NUM];

D3DXVECTOR3    CGrannyMaterial::ms_v3SpecularTrans(0.0f, 0.0f, 0.0f);
D3DXMATRIX    CGrannyMaterial::ms_matSpecular;

D3DXCOLOR g_fSpecularColor = D3DXCOLOR(0.0f, 0.0f, 0.0f, 0.0f);

void CGrannyMaterial::TranslateSpecularMatrix(float fAddX, float fAddY, float fAddZ)
{
    static float SPECULAR_TRANSLATE_MAX = 1000000.0f;

    ms_v3SpecularTrans.x += fAddX;
    ms_v3SpecularTrans.y += fAddY;
    ms_v3SpecularTrans.z += fAddZ;

    if (ms_v3SpecularTrans.x >= SPECULAR_TRANSLATE_MAX)
        ms_v3SpecularTrans.x = 0.0f;

    if (ms_v3SpecularTrans.y >= SPECULAR_TRANSLATE_MAX)
        ms_v3SpecularTrans.y = 0.0f;

    if (ms_v3SpecularTrans.z >= SPECULAR_TRANSLATE_MAX)
        ms_v3SpecularTrans.z = 0.0f;

    D3DXMatrixTranslation(&ms_matSpecular,
        ms_v3SpecularTrans.x,
        ms_v3SpecularTrans.y,
        ms_v3SpecularTrans.z
    );

    STATEMANAGER.SetPixelShaderConstant(91, &ms_v3SpecularTrans, 1);
}

void CGrannyMaterial::ApplyRenderState()
{
    assert(m_pfnApplyRenderState != NULL && "CGrannyMaterial::SaveRenderState");
    (this->*m_pfnApplyRenderState)();
}

void CGrannyMaterial::RestoreRenderState()
{
    assert(m_pfnRestoreRenderState != NULL && "CGrannyMaterial::RestoreRenderState");
    (this->*m_pfnRestoreRenderState)();
}

void CGrannyMaterial::Copy(CGrannyMaterial& rkMtrl)
{
    m_pgrnMaterial = rkMtrl.m_pgrnMaterial;
    m_roImage[0] = rkMtrl.m_roImage[0];
    m_roImage[1] = rkMtrl.m_roImage[1];
    m_eType = rkMtrl.m_eType;
}

CGrannyMaterial::CGrannyMaterial()
{
    m_bTwoSideRender = false;
    m_dwLastCullRenderStateForTwoSideRendering = D3DCULL_CW;

    Initialize();
}

CGrannyMaterial::~CGrannyMaterial()
{
}

CGrannyMaterial::EType CGrannyMaterial::GetType() const
{
    return m_eType;
}

void CGrannyMaterial::SetImagePointer(int iStage, CGraphicImage* pImage)
{
    assert(iStage < 2 && "CGrannyMaterial::SetImagePointer");
    m_roImage[iStage] = pImage;
}

bool CGrannyMaterial::IsIn(const char* c_szImageName, int* piStage)
{
    std::string strImageName = c_szImageName;
    CFileNameHelper::StringPath(strImageName);

    granny_texture* pgrnDiffuseTexture = GrannyGetMaterialTextureByType(m_pgrnMaterial, GrannyDiffuseColorTexture);
    if (pgrnDiffuseTexture)
    {
        std::string strDiffuseFileName = pgrnDiffuseTexture->FromFileName;
        CFileNameHelper::StringPath(strDiffuseFileName);
        if (strDiffuseFileName == strImageName)
        {
            *piStage = 0;
            return true;
        }
    }

    granny_texture* pgrnOpacityTexture = GrannyGetMaterialTextureByType(m_pgrnMaterial, GrannyOpacityTexture);
    if (pgrnOpacityTexture)
    {
        std::string strOpacityFileName = pgrnOpacityTexture->FromFileName;
        CFileNameHelper::StringPath(strOpacityFileName);
        if (strOpacityFileName == strImageName)
        {
            *piStage = 1;
            return true;
        }
    }

    return false;
}

void CGrannyMaterial::SetSpecularInfo(BOOL bFlag, float fPower, BYTE uSphereMapIndex)
{
    m_fSpecularPower = fPower;
    m_bSphereMapIndex = uSphereMapIndex;
    m_bSpecularEnable = bFlag;

    if (bFlag)
    {
        m_pfnApplyRenderState = &CGrannyMaterial::__ApplySpecularRenderState;
        m_pfnRestoreRenderState = &CGrannyMaterial::__RestoreSpecularRenderState;
    }
    else
    {
        m_pfnApplyRenderState = &CGrannyMaterial::__ApplyDiffuseRenderState;
        m_pfnRestoreRenderState = &CGrannyMaterial::__RestoreDiffuseRenderState;
    }
}

bool CGrannyMaterial::IsEqual(granny_material* pgrnMaterial) const
{
    if (m_pgrnMaterial == pgrnMaterial)
        return true;

    return false;
}

LPDIRECT3DTEXTURE8 CGrannyMaterial::GetD3DTexture(int iStage) const
{
    const CGraphicImage::TRef& ratImage = m_roImage[iStage];

    if (ratImage.IsNull())
        return NULL;

    CGraphicImage* pImage = ratImage.GetPointer();
    const CGraphicTexture* pTexture = pImage->GetTexturePointer();
    return pTexture->GetD3DTexture();
}

CGraphicImage* CGrannyMaterial::GetImagePointer(int iStage) const
{
    const CGraphicImage::TRef& ratImage = m_roImage[iStage];

    if (ratImage.IsNull())
        return NULL;

    CGraphicImage* pImage = ratImage.GetPointer();
    return pImage;
}

const CGraphicTexture* CGrannyMaterial::GetDiffuseTexture() const
{
    if (m_roImage[0].IsNull())
        return NULL;

    return m_roImage[0].GetPointer()->GetTexturePointer();
}

const CGraphicTexture* CGrannyMaterial::GetOpacityTexture() const
{
    if (m_roImage[1].IsNull())
        return NULL;

    return m_roImage[1].GetPointer()->GetTexturePointer();
}

BOOL CGrannyMaterial::__IsSpecularEnable() const
{
    return m_bSpecularEnable;
}

float CGrannyMaterial::GetSpecularPower() const
{
    return m_fSpecularPower;
}

extern const std::string& GetModelLocalPath();

CGraphicImage* CGrannyMaterial::__GetImagePointer(const char* fileName)
{
    assert(*fileName != '\0');

    CResourceManager& rkResMgr = CResourceManager::Instance();

    // SUPPORT_LOCAL_TEXTURE
    int fileName_len = strlen(fileName);
    if (fileName_len > 2 && fileName[1] != ':')
    {
        char localFileName[256];
        const std::string& modelLocalPath = GetModelLocalPath();

        int localFileName_len = modelLocalPath.length() + 1 + fileName_len;
        if (localFileName_len < sizeof(localFileName) - 1)
        {
            _snprintf(localFileName, sizeof(localFileName), "%s%s", GetModelLocalPath().c_str(), fileName);
            CResource* pResource = rkResMgr.GetResourcePointer(localFileName);
            return static_cast<CGraphicImage*>(pResource);
        }
    }
    // END_OF_SUPPORT_LOCAL_TEXTURE

    CResource* pResource = rkResMgr.GetResourcePointer(fileName);
    return static_cast<CGraphicImage*>(pResource);
}

bool CGrannyMaterial::CreateFromGrannyMaterialPointer(granny_material* pgrnMaterial)
{
    m_pgrnMaterial = pgrnMaterial;

    granny_texture* pgrnDiffuseTexture = NULL;
    granny_texture* pgrnOpacityTexture = NULL;

    if (pgrnMaterial)
    {
        if (pgrnMaterial->MapCount > 1 && !_strnicmp(pgrnMaterial->Name, "Blend", 5))
        {
            pgrnDiffuseTexture = GrannyGetMaterialTextureByType(pgrnMaterial->Maps[0].Material, GrannyDiffuseColorTexture);
            pgrnOpacityTexture = GrannyGetMaterialTextureByType(pgrnMaterial->Maps[1].Material, GrannyDiffuseColorTexture);
        }
        else
        {
            pgrnDiffuseTexture = GrannyGetMaterialTextureByType(m_pgrnMaterial, GrannyDiffuseColorTexture);
            pgrnOpacityTexture = GrannyGetMaterialTextureByType(m_pgrnMaterial, GrannyOpacityTexture);
        }

        {
            granny_int32 twoSided = 0;
            granny_data_type_definition TwoSidedFieldType[] =
            {
                {GrannyInt32Member, "Two-sided"},
                {GrannyEndMember},
            };
#if GrannyProductMinorVersion==4
            granny_variant twoSideResult = GrannyFindMatchingMember(pgrnMaterial->ExtendedData.Type, pgrnMaterial->ExtendedData.Object, "Two-sided");

            if (NULL != twoSideResult.Type)
                GrannyConvertSingleObject(twoSideResult.Type, twoSideResult.Object, TwoSidedFieldType, &twoSided);
#elif GrannyProductMinorVersion==7
            granny_variant twoSideResult;
            bool findMatchResult = GrannyFindMatchingMember(pgrnMaterial->ExtendedData.Type, pgrnMaterial->ExtendedData.Object, "Two-sided", &twoSideResult);
            if (NULL != twoSideResult.Type && findMatchResult)
                GrannyConvertSingleObject(twoSideResult.Type, twoSideResult.Object, TwoSidedFieldType, &twoSided);
#elif GrannyProductMinorVersion==11 || GrannyProductMinorVersion==9 || GrannyProductMinorVersion==8
            granny_variant twoSideResult;
            bool gfmm_bool = GrannyFindMatchingMember(pgrnMaterial->ExtendedData.Type, pgrnMaterial->ExtendedData.Object, "Two-sided", &twoSideResult);
            if (NULL != twoSideResult.Type)
                GrannyConvertSingleObject(twoSideResult.Type, twoSideResult.Object, TwoSidedFieldType, &twoSided, 0);
#else
#error "unknown granny version"
#endif

            m_bTwoSideRender = 1 == twoSided;
        }
    }

    if (pgrnDiffuseTexture)
        m_roImage[0].SetPointer(__GetImagePointer(pgrnDiffuseTexture->FromFileName));

    if (pgrnOpacityTexture)
        m_roImage[1].SetPointer(__GetImagePointer(pgrnOpacityTexture->FromFileName));

    if (!m_roImage[1].IsNull())
        m_eType = TYPE_BLEND_PNT;
    else
        m_eType = TYPE_DIFFUSE_PNT;

    return true;
}

void CGrannyMaterial::Initialize()
{
    m_roImage[0] = NULL;
    m_roImage[1] = NULL;

    SetSpecularInfo(FALSE, 0.0f, 0);
}

void CGrannyMaterial::__ApplyDiffuseRenderState()
{
    STATEMANAGER.SetTexture(0, GetD3DTexture(0));

    if (m_bTwoSideRender)
    {
        m_dwLastCullRenderStateForTwoSideRendering = STATEMANAGER.GetRenderState(D3DRS_CULLMODE);
        STATEMANAGER.SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    }
}

void CGrannyMaterial::__RestoreDiffuseRenderState()
{
    if (m_bTwoSideRender)
    {
        STATEMANAGER.SetRenderState(D3DRS_CULLMODE, m_dwLastCullRenderStateForTwoSideRendering);
    }
}

void CGrannyMaterial::__ApplySpecularRenderState()
{
    if (TRUE == STATEMANAGER.GetRenderState(D3DRS_ALPHABLENDENABLE))
    {
        __ApplyDiffuseRenderState();
        return;
    }

    CGraphicTexture* pkTexture = ms_akSphereMapInstance[m_bSphereMapIndex].GetTexturePointer();

    STATEMANAGER.SetTexture(0, GetD3DTexture(0));

    if (pkTexture)
    {
        STATEMANAGER.SetSamplerState(1, D3DSAMP_MIPMAPLODBIAS, -1);
        STATEMANAGER.SetTexture(1, pkTexture->GetD3DTexture());
    }
    else
        STATEMANAGER.SetTexture(1, NULL);

    STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, D3DXCOLOR(g_fSpecularColor.r, g_fSpecularColor.g, g_fSpecularColor.b, GetSpecularPower()));
    float SpecularPower = GetSpecularPower();

    if (SpecularPower > 1.0f)
        SpecularPower = 1.0f;

    STATEMANAGER.SetPixelShaderConstant(92, &SpecularPower, 1);
    STATEMANAGER.SaveTextureStageState(1, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
    STATEMANAGER.SaveTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
    STATEMANAGER.SaveTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
    STATEMANAGER.SaveTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
    STATEMANAGER.SaveTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
    STATEMANAGER.SaveTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_TFACTOR);
    STATEMANAGER.SaveTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);

    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_CURRENT);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_TEXTURE);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_MODULATEALPHA_ADDCOLOR);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);

    STATEMANAGER.SetTransform(D3DTS_TEXTURE1, &ms_matSpecular);
    STATEMANAGER.SaveTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
#ifdef DIRECTX9
    STATEMANAGER.SaveSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
    STATEMANAGER.SaveSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
#else
    STATEMANAGER.SaveTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
    STATEMANAGER.SaveTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
#endif
}

void CGrannyMaterial::__RestoreSpecularRenderState()
{
    if (TRUE == STATEMANAGER.GetRenderState(D3DRS_ALPHABLENDENABLE))
    {
        __RestoreDiffuseRenderState();
        return;
    }

    STATEMANAGER.RestoreTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS);
#ifdef DIRECTX9
    STATEMANAGER.RestoreSamplerState(1, D3DSAMP_ADDRESSU);
    STATEMANAGER.RestoreSamplerState(1, D3DSAMP_ADDRESSV);
#else
    STATEMANAGER.RestoreTextureStageState(1, D3DTSS_ADDRESSU);
    STATEMANAGER.RestoreTextureStageState(1, D3DTSS_ADDRESSV);
#endif

    STATEMANAGER.RestoreTextureStageState(1, D3DTSS_TEXCOORDINDEX);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);

    STATEMANAGER.RestoreTextureStageState(0, D3DTSS_COLORARG1);
    STATEMANAGER.RestoreTextureStageState(0, D3DTSS_COLORARG2);
    STATEMANAGER.RestoreTextureStageState(0, D3DTSS_COLOROP);
    STATEMANAGER.RestoreTextureStageState(0, D3DTSS_ALPHAARG1);
    STATEMANAGER.RestoreTextureStageState(0, D3DTSS_ALPHAARG2);
    STATEMANAGER.RestoreTextureStageState(0, D3DTSS_ALPHAOP);
}

void CGrannyMaterial::CreateSphereMap(UINT uMapIndex, const char* c_szSphereMapImageFileName)
{
    CResourceManager& rkResMgr = CResourceManager::Instance();
    CGraphicImage* pImage = (CGraphicImage*)rkResMgr.GetResourcePointer(c_szSphereMapImageFileName);
    ms_akSphereMapInstance[uMapIndex].SetImagePointer(pImage);
}

void CGrannyMaterial::DestroySphereMap()
{
    for (UINT uMapIndex = 0; uMapIndex < SPHEREMAP_NUM; ++uMapIndex)
        ms_akSphereMapInstance[uMapIndex].Destroy();
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

CGrannyMaterialPalette::CGrannyMaterialPalette()
{
}

CGrannyMaterialPalette::~CGrannyMaterialPalette()
{
    Clear();
}

void CGrannyMaterialPalette::Copy(const CGrannyMaterialPalette& rkMtrlPalSrc)
{
    m_mtrlVector = rkMtrlPalSrc.m_mtrlVector;
}

void CGrannyMaterialPalette::Clear()
{
    m_mtrlVector.clear();
}

CGrannyMaterial& CGrannyMaterialPalette::GetMaterialRef(DWORD mtrlIndex)
{
    assert(mtrlIndex < m_mtrlVector.size());
    return *m_mtrlVector[mtrlIndex].GetPointer();
}

void CGrannyMaterialPalette::SetMaterialImagePointer(const char* c_szImageName, CGraphicImage* pImage)
{
    DWORD size = m_mtrlVector.size();
    DWORD i;
    for (i = 0; i < size; ++i)
    {
        CGrannyMaterial::TRef& roMtrl = m_mtrlVector[i];

        int iStage;
        if (roMtrl->IsIn(c_szImageName, &iStage))
        {
            CGrannyMaterial* pkNewMtrl = new CGrannyMaterial;
            pkNewMtrl->Copy(*roMtrl.GetPointer());
            pkNewMtrl->SetImagePointer(iStage, pImage);
            roMtrl = pkNewMtrl;

            return;
        }
    }
}

void CGrannyMaterialPalette::SetMaterialData(const char* c_szMtrlName, const SMaterialData& c_rkMaterialData)
{
    if (c_szMtrlName)
    {
        std::vector<CGrannyMaterial::TRef>::iterator i;
        for (i = m_mtrlVector.begin(); i != m_mtrlVector.end(); ++i)
        {
            CGrannyMaterial::TRef& roMtrl = *i;

            int iStage;
            if (roMtrl->IsIn(c_szMtrlName, &iStage))
            {
                CGrannyMaterial* pkNewMtrl = new CGrannyMaterial;
                pkNewMtrl->Copy(*roMtrl.GetPointer());
                pkNewMtrl->SetImagePointer(iStage, c_rkMaterialData.pImage);
                pkNewMtrl->SetSpecularInfo(c_rkMaterialData.isSpecularEnable, c_rkMaterialData.fSpecularPower, c_rkMaterialData.bSphereMapIndex);
                roMtrl = pkNewMtrl;

                return;
            }
        }
    }
    else
    {
        std::vector<CGrannyMaterial::TRef>::iterator i;
        for (i = m_mtrlVector.begin(); i != m_mtrlVector.end(); ++i)
        {
            CGrannyMaterial::TRef& roMtrl = *i;
            roMtrl->SetSpecularInfo(c_rkMaterialData.isSpecularEnable, c_rkMaterialData.fSpecularPower, c_rkMaterialData.bSphereMapIndex);
        }
    }
}

void CGrannyMaterialPalette::SetSpecularInfo(const char* c_szMtrlName, BOOL bEnable, float fPower)
{
    DWORD size = m_mtrlVector.size();
    DWORD i;
    if (c_szMtrlName)
    {
        for (i = 0; i < size; ++i)
        {
            CGrannyMaterial::TRef& roMtrl = m_mtrlVector[i];

            int iStage;
            if (roMtrl->IsIn(c_szMtrlName, &iStage))
            {
                roMtrl->SetSpecularInfo(bEnable, fPower, 0);
                return;
            }
        }
    }
    else
    {
        for (i = 0; i < size; ++i)
        {
            CGrannyMaterial::TRef& roMtrl = m_mtrlVector[i];
            roMtrl->SetSpecularInfo(bEnable, fPower, 0);
        }
    }
}

DWORD CGrannyMaterialPalette::RegisterMaterial(granny_material* pgrnMaterial)
{
    DWORD size = m_mtrlVector.size();
    DWORD i;
    for (i = 0; i < size; ++i)
    {
        CGrannyMaterial::TRef& roMtrl = m_mtrlVector[i];
        if (roMtrl->IsEqual(pgrnMaterial))
            return i;
    }

    CGrannyMaterial* pkNewMtrl = new CGrannyMaterial;
    pkNewMtrl->CreateFromGrannyMaterialPointer(pgrnMaterial);
    m_mtrlVector.push_back(pkNewMtrl);

    return size;
}

DWORD CGrannyMaterialPalette::GetMaterialCount() const
{
    return m_mtrlVector.size();
}
//martysama0134's 747bda46b83d0f642ccb846d9a8c1cbe

​
 
Tarihe göre sırala Oy skoruna göre sırala
Durum
İçerik kilitlendiği için mesaj gönderimine kapatıldı.

Benzer konular

suleyman06
  • Kilitli
Çözüldü Sistem Ekleme-05
Yanıt
2
Gösterim
534
suleyman06
suleyman06
SULEYMAN BOZOK
  • Kilitli
Çözüldü Buıld Hatası Kodlama
Yanıt
1
Gösterim
83
SULEYMAN BOZOK
SULEYMAN BOZOK
SULEYMAN BOZOK
  • Kilitli
  • Çözüldü
Çözüldü Lonca Lider Ve General + Nick Yanında Bulunan Türk Bayragı Iconu Sılmek İstiyorum
Yanıt
8
Gösterim
192
SULEYMAN BOZOK
SULEYMAN BOZOK
Redix
Yardım Directx9 water problemi
Yanıt
8
Gösterim
929
Redix
Redix
suleyman06
  • Kilitli
Çözüldü OfflineShop Sistem Ekleme-02
Yanıt
6
Gösterim
973
suleyman06
suleyman06
Geri
Üst