Jump to content

Zeia

Premium
 View Profile  See their activity

  • Posts

    29

  • Joined

  • Last visited

  • Feedback

    0%

 Content Type 

Forums

Store

Third Party - Providers Directory

Feature Plan

Release Notes

Docs

Events

Posts posted by Zeia

    Metin2 client.exe Directx9 Update Problem

    in Community Support - Questions & Answers

    Posted

    2>eterlib.lib(Camera.obj) : error LNK2001: unresolved external symbol _D3DXMatrixDeterminant@4
    2>eterlib.lib(GrpDevice.obj) : error LNK2001: unresolved external symbol _Direct3DCreate9@4
    2>Distribute/metin2client.exe : fatal error LNK1120: 2 unresolved externals
     
    Please Help Me ;
     
    Direct3DCreate9 :
     
    int CGraphicDevice::Create(HWND hWnd, int iHres, int iVres, bool Windowed, int /*iBit*/, int iReflashRate)
    {
        int iRet = CREATE_OK;
     
        Destroy();
     
        ms_iWidth   = iHres;
        ms_iHeight  = iVres;
     
        ms_hWnd     = hWnd;
        ms_hDC      = GetDC(hWnd);
        ms_lpd3d    = Direct3DCreate9(D3D_SDK_VERSION);
     
        if (!ms_lpd3d)
            return CREATE_NO_DIRECTX;
     
        if (!ms_kD3DDetector.Build(*ms_lpd3d, EL3D_ConfirmDevice))
            return CREATE_ENUM;
     
        if (!ms_kD3DDetector.Find(800, 600, 32, TRUE, &ms_iD3DModeInfo, &ms_iD3DDevInfo, &ms_iD3DAdapterInfo))
            return CREATE_DETECT;
     
        std::string stDevList;
        ms_kD3DDetector.GetString(&stDevList);
     
        //Tracen(stDevList.c_str());
        //Tracenf("adapter %d, device %d, mode %d", ms_iD3DAdapterInfo, ms_iD3DDevInfo, ms_iD3DModeInfo);
     
        D3D_CAdapterInfo * pkD3DAdapterInfo = ms_kD3DDetector.GetD3DAdapterInfop(ms_iD3DAdapterInfo);
        if (!pkD3DAdapterInfo)
        {
            Tracenf("adapter %d is EMPTY", ms_iD3DAdapterInfo);
            return CREATE_DETECT;
        }
     
        if (__IsInDriverBlackList(*pkD3DAdapterInfo))
        {
            iRet |= CREATE_BAD_DRIVER;
            __WarningMessage(hWnd, CREATE_BAD_DRIVER);
        }
     
        D3D_SModeInfo * pkD3DModeInfo = pkD3DAdapterInfo->GetD3DModeInfop(ms_iD3DDevInfo, ms_iD3DModeInfo);     
        if (!pkD3DModeInfo)
        {
            Tracenf("device %d, mode %d is EMPTY", ms_iD3DDevInfo, ms_iD3DModeInfo);
            return CREATE_DETECT;
        }
     
        D3DADAPTER_IDENTIFIER9& rkD3DAdapterId=pkD3DAdapterInfo->GetIdentifier();
        if (Windowed &&
            strnicmp(rkD3DAdapterId.Driver, "3dfx", 4)==0 &&
            22 == pkD3DAdapterInfo->GetDesktopD3DDisplayModer().Format)
        {
            return CREATE_FORMAT;
        }
     
        if (pkD3DModeInfo->m_dwD3DBehavior==D3DCREATE_SOFTWARE_VERTEXPROCESSING)
        {
            iRet |= CREATE_NO_TNL;
     
            // DISABLE_NOTIFY_NOT_SUPPORT_TNL_MESSAGE
            //__WarningMessage(hWnd, CREATE_NO_TNL);
            // END_OF_DISABLE_NOTIFY_NOT_SUPPORT_TNL_MESSAGE
        }
     
        std::string stModeInfo;
        pkD3DModeInfo->GetString(&stModeInfo);
     
        //Tracen(stModeInfo.c_str());
     
        int ErrorCorrection = 0;
     
    RETRY:
        ZeroMemory(&ms_d3dPresentParameter, sizeof(ms_d3dPresentParameter));
        
        ms_d3dPresentParameter.Windowed                         = Windowed;
        ms_d3dPresentParameter.BackBufferWidth                  = iHres;
        ms_d3dPresentParameter.BackBufferHeight                 = iVres;
        ms_d3dPresentParameter.hDeviceWindow                    = hWnd;
        ms_d3dPresentParameter.BackBufferCount                  = m_uBackBufferCount;
        ms_d3dPresentParameter.SwapEffect                       = D3DSWAPEFFECT_DISCARD;
     
        if (Windowed)
        {
            ms_d3dPresentParameter.BackBufferFormat             = pkD3DAdapterInfo->GetDesktopD3DDisplayModer().Format;
        }
        else
        {
            ms_d3dPresentParameter.BackBufferFormat             = pkD3DModeInfo->m_eD3DFmtPixel;
            ms_d3dPresentParameter.FullScreen_RefreshRateInHz   = iReflashRate;
        }
     
        ms_d3dPresentParameter.Flags                            = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
        ms_d3dPresentParameter.EnableAutoDepthStencil           = TRUE;
        ms_d3dPresentParameter.AutoDepthStencilFormat           = pkD3DModeInfo->m_eD3DFmtDepthStencil;
     
        ms_dwD3DBehavior = pkD3DModeInfo->m_dwD3DBehavior;
     
        if (FAILED(ms_hLastResult = ms_lpd3d->CreateDevice(
                    ms_iD3DAdapterInfo,
                    D3DDEVTYPE_HAL,
                    hWnd,
                    // 2004. 1. 9 myevan 버텍스 프로세싱 방식 자동 선택 추가
                    pkD3DModeInfo->m_dwD3DBehavior,
                    &ms_d3dPresentParameter,
                    &ms_lpd3dDevice)))
        {
            switch (ms_hLastResult)
            {
                case D3DERR_INVALIDCALL:
                    Tracen("IDirect3DDevice.CreateDevice - ERROR D3DERR_INVALIDCALLnThe method call is invalid. For example, a method's parameter may have an invalid value.");                   
                    break;
                case D3DERR_NOTAVAILABLE:
                    Tracen("IDirect3DDevice.CreateDevice - ERROR D3DERR_NOTAVAILABLEnThis device does not support the queried technique. ");
                    break;
                case D3DERR_OUTOFVIDEOMEMORY:
                    Tracen("IDirect3DDevice.CreateDevice - ERROR D3DERR_OUTOFVIDEOMEMORYnDirect3D does not have enough display memory to perform the operation");
                    break;
                default:
                    Tracenf("IDirect3DDevice.CreateDevice - ERROR %d", ms_hLastResult);
                    break;
            }
     
            if (ErrorCorrection)
                return CREATE_DEVICE;
        
            // 2004. 1. 9 myevan 큰의미 없는 코드인듯.. 에러나면 표시하고 종료하자
            iReflashRate = 0;
            ++ErrorCorrection;
            iRet = CREATE_REFRESHRATE;
            goto RETRY;
        }
     
        // Check DXT Support Info
        if(ms_lpd3d->CheckDeviceFormat(
                    ms_iD3DAdapterInfo,
                    D3DDEVTYPE_HAL,
                    ms_d3dPresentParameter.BackBufferFormat,
                    0,
                    D3DRTYPE_TEXTURE,
                    D3DFMT_DXT1) == D3DERR_NOTAVAILABLE)
        {
            ms_bSupportDXT = false;
        }
     
        if(ms_lpd3d->CheckDeviceFormat(
                    ms_iD3DAdapterInfo,
                    D3DDEVTYPE_HAL,
                    ms_d3dPresentParameter.BackBufferFormat,
                    0,
                    D3DRTYPE_TEXTURE,
                    D3DFMT_DXT3) == D3DERR_NOTAVAILABLE)
        {
            ms_bSupportDXT = false;
        }
     
        if(ms_lpd3d->CheckDeviceFormat(
                    ms_iD3DAdapterInfo,
                    D3DDEVTYPE_HAL,
                    ms_d3dPresentParameter.BackBufferFormat,
                    0,
                    D3DRTYPE_TEXTURE,
                    D3DFMT_DXT5) == D3DERR_NOTAVAILABLE)
        {
            ms_bSupportDXT = false;
        }  
     
        if (FAILED((ms_hLastResult = ms_lpd3dDevice->GetDeviceCaps(&ms_d3dCaps))))
        {
            Tracenf("IDirect3DDevice.GetDeviceCaps - ERROR %d", ms_hLastResult);
            return CREATE_GET_DEVICE_CAPS2;
        }
     
        if (!Windowed)
            SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, iHres, iVres, SWP_SHOWWINDOW);
     
        //Tracef("vertex shader version : %Xn",(DWORD)ms_d3dCaps.VertexShaderVersion);
     
        ms_lpd3dDevice->GetViewport(&ms_Viewport);
     
        m_pStateManager = new CStateManager(ms_lpd3dDevice);
     
        D3DXCreateMatrixStack(0, &ms_lpd3dMatStack);
        ms_lpd3dMatStack->LoadIdentity();
     
        ms_ptVS = CreatePTStreamVertexShader();
        ms_pntVS = CreatePNTStreamVertexShader();
        ms_pnt2VS = CreatePNT2StreamVertexShader();
     
        D3DXMatrixIdentity(&ms_matIdentity);
        D3DXMatrixIdentity(&ms_matView);
        D3DXMatrixIdentity(&ms_matProj);
        D3DXMatrixIdentity(&ms_matInverseView);
        D3DXMatrixIdentity(&ms_matInverseViewYAxis);
        D3DXMatrixIdentity(&ms_matScreen0);
        D3DXMatrixIdentity(&ms_matScreen1);
        D3DXMatrixIdentity(&ms_matScreen2);
     
        ms_matScreen0._11 = 1;
        ms_matScreen0._22 = -1;
     
        ms_matScreen1._41 = 1;
        ms_matScreen1._42 = 1;
     
        ms_matScreen2._11 = (float) iHres / 2;
        ms_matScreen2._22 = (float) iVres / 2;
        
        D3DXCreateSphere(ms_lpd3dDevice, 1.0f, 32, 32, &ms_lpSphereMesh, NULL);
        D3DXCreateCylinder(ms_lpd3dDevice, 1.0f, 1.0f, 1.0f, 8, 8, &ms_lpCylinderMesh, NULL);
     
        ms_lpd3dDevice->Clear(0L, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff000000, 1.0f, 0);
     
        if (!__CreateDefaultIndexBufferList())
            return false;
     
        if (!__CreatePDTVertexBufferList())
            return false;
        
        DWORD dwTexMemSize = GetAvailableTextureMemory();
     
        if (dwTexMemSize < 64 * 1024 * 1024)
            ms_isLowTextureMemory = true;
        else
            ms_isLowTextureMemory = false;
     
        if (dwTexMemSize > 100 * 1024 * 1024)
            ms_isHighTextureMemory = true;
        else
            ms_isHighTextureMemory = false;
     
        if (ms_d3dCaps.TextureAddressCaps & D3DPTADDRESSCAPS_BORDER)
            GRAPHICS_CAPS_CAN_NOT_TEXTURE_ADDRESS_BORDER=false;
        else
            GRAPHICS_CAPS_CAN_NOT_TEXTURE_ADDRESS_BORDER=true;
     
        //D3DADAPTER_IDENTIFIER9& rkD3DAdapterId=pkD3DAdapterInfo->GetIdentifier();
        if (strnicmp(rkD3DAdapterId.Driver, "SIS", 3) == 0)
        {
            GRAPHICS_CAPS_CAN_NOT_DRAW_LINE = true;
            GRAPHICS_CAPS_CAN_NOT_DRAW_SHADOW = true;
            GRAPHICS_CAPS_HALF_SIZE_IMAGE = true;
            ms_isLowTextureMemory = true;
        }
        else if (strnicmp(rkD3DAdapterId.Driver, "3dfx", 4) == 0)
        {
            GRAPHICS_CAPS_CAN_NOT_DRAW_SHADOW = true;
            GRAPHICS_CAPS_HALF_SIZE_IMAGE = true;
            ms_isLowTextureMemory = true;
        }
     
        return (iRet);
    }

    Matrix :

    void CCamera::SetViewMatrix()
    {
        m_v3View = m_v3Target - m_v3Eye;
        D3DXVECTOR3 v3CenterRay = -m_v3View;
        CalculateRoll();
        m_fDistance = D3DXVec3Length(&m_v3View);
        assert(m_fDistance >= 0);
        D3DXVec3Normalize(&m_v3View , &m_v3View);
     
        D3DXVec3Cross(&m_v3Cross, &m_v3Up, &m_v3View);
        D3DXVec3Normalize(&m_v3Cross, &m_v3Cross);
     
        D3DXVec3Cross(&m_v3Up, &m_v3View, &m_v3Cross);
        D3DXVec3Normalize(&m_v3Up, &m_v3Up);
     
        m_fPitch = D3DXVec3Dot(&m_v3Up, &D3DXVECTOR3(0.0f, 0.0f, 1.0f));// / D3DXVec2Length(&v2ViewYZ);
        if (m_fPitch >= 1)
            m_fPitch = 1;
        else if (m_fPitch <= -1)
            m_fPitch = -1;
        m_fPitch = acosf(m_fPitch);
        m_fPitch *= (180.0f / D3DX_PI);
        if ( 0 < m_v3View.z )
            m_fPitch = -m_fPitch;
     
        D3DXMatrixLookAtRH(&m_matView, &m_v3Eye, &m_v3Target, &m_v3Up);
     
        float fDeterminantD3DMatView = D3DXMatrixDeterminant(&m_matView);
        D3DXMatrixInverse(&m_matInverseView, &fDeterminantD3DMatView, &m_matView);
     
        m_matBillboard = m_matInverseView;
        m_matBillboard._41 = 0.0f;
        m_matBillboard._42 = 0.0f;
        m_matBillboard._43 = 0.0f;
     
        m_ViewRay.SetStartPoint(m_v3Target);
        m_ViewRay.SetDirection(v3CenterRay, m_fDistance);
     
        m_kCameraBottomToTerrainRay.SetStartPoint(m_v3Eye);
        m_kCameraFrontToTerrainRay.SetStartPoint(m_v3Eye);
        m_kCameraBackToTerrainRay.SetStartPoint(m_v3Eye);
        m_kCameraLeftToTerrainRay.SetStartPoint(m_v3Eye);
        m_kCameraRightToTerrainRay.SetStartPoint(m_v3Eye);
        m_kTargetToCameraBottomRay.SetStartPoint(m_v3Target);
     
        m_kCameraBottomToTerrainRay.SetDirection(-m_v3Up, 2.0f * m_fTerrainCollisionRadius);
        m_kCameraFrontToTerrainRay.SetDirection(m_v3View, 4.0f * m_fTerrainCollisionRadius);
        m_kCameraBackToTerrainRay.SetDirection(-m_v3View, m_fTerrainCollisionRadius);
        m_kCameraLeftToTerrainRay.SetDirection(-m_v3Cross, 3.0f * m_fTerrainCollisionRadius);
        m_kCameraRightToTerrainRay.SetDirection(m_v3Cross, 3.0f * m_fTerrainCollisionRadius);
        m_kTargetToCameraBottomRay.SetDirection(v3CenterRay - m_fTerrainCollisionRadius * m_v3Up,
            D3DXVec3Length(&(v3CenterRay - m_fTerrainCollisionRadius * m_v3Up)));
     
        m_kLeftObjectCollisionRay.SetStartPoint(m_v3Target);
        m_kTopObjectCollisionRay.SetStartPoint(m_v3Target);
        m_kRightObjectCollisionRay.SetStartPoint(m_v3Target);
        m_kBottomObjectCollisionRay.SetStartPoint(m_v3Target);
     
        m_kLeftObjectCollisionRay.SetDirection(v3CenterRay + m_fObjectCollisionRadius * m_v3Cross,
            D3DXVec3Length(&(v3CenterRay + m_fObjectCollisionRadius * m_v3Cross)));
        m_kRightObjectCollisionRay.SetDirection(v3CenterRay - m_fObjectCollisionRadius * m_v3Cross,
            D3DXVec3Length(&(v3CenterRay - m_fObjectCollisionRadius * m_v3Cross)));
        m_kTopObjectCollisionRay.SetDirection(v3CenterRay + m_fObjectCollisionRadius * m_v3Up,
            D3DXVec3Length(&(v3CenterRay + m_fObjectCollisionRadius * m_v3Up)));
        m_kBottomObjectCollisionRay.SetDirection(v3CenterRay - m_fObjectCollisionRadius * m_v3Up,
            D3DXVec3Length(&(v3CenterRay + m_fObjectCollisionRadius * m_v3Up)));
    }

     

    Metin2 Client.exe Directx9 Update Problem.

    in Community Support - Questions & Answers

    Posted

    2>eterlib.lib(Camera.obj) : error LNK2001: unresolved external symbol _D3DXMatrixDeterminant@4
    2>eterlib.lib(GrpDevice.obj) : error LNK2001: unresolved external symbol _Direct3DCreate9@4
    2>Distribute/metin2client.exe : fatal error LNK1120: 2 unresolved externals
     
    Please Help Me ;
     
    Direct3DCreate9 :
     
    int CGraphicDevice::Create(HWND hWnd, int iHres, int iVres, bool Windowed, int /*iBit*/, int iReflashRate)
{
	int iRet = CREATE_OK;

	Destroy();

	ms_iWidth	= iHres;
	ms_iHeight	= iVres;

	ms_hWnd		= hWnd;
	ms_hDC		= GetDC(hWnd);
	ms_lpd3d	= Direct3DCreate9(D3D_SDK_VERSION);

	if (!ms_lpd3d)
		return CREATE_NO_DIRECTX;

	if (!ms_kD3DDetector.Build(*ms_lpd3d, EL3D_ConfirmDevice))
		return CREATE_ENUM;

	if (!ms_kD3DDetector.Find(800, 600, 32, TRUE, &ms_iD3DModeInfo, &ms_iD3DDevInfo, &ms_iD3DAdapterInfo))
		return CREATE_DETECT;

	std::string stDevList;
	ms_kD3DDetector.GetString(&stDevList);

	//Tracen(stDevList.c_str());
	//Tracenf("adapter %d, device %d, mode %d", ms_iD3DAdapterInfo, ms_iD3DDevInfo, ms_iD3DModeInfo);

	D3D_CAdapterInfo * pkD3DAdapterInfo = ms_kD3DDetector.GetD3DAdapterInfop(ms_iD3DAdapterInfo);
	if (!pkD3DAdapterInfo)
	{
		Tracenf("adapter %d is EMPTY", ms_iD3DAdapterInfo);
		return CREATE_DETECT;
	}

	if (__IsInDriverBlackList(*pkD3DAdapterInfo))
	{
		iRet |= CREATE_BAD_DRIVER;
		__WarningMessage(hWnd, CREATE_BAD_DRIVER);
	}

	D3D_SModeInfo * pkD3DModeInfo = pkD3DAdapterInfo->GetD3DModeInfop(ms_iD3DDevInfo, ms_iD3DModeInfo);		
	if (!pkD3DModeInfo)
	{
		Tracenf("device %d, mode %d is EMPTY", ms_iD3DDevInfo, ms_iD3DModeInfo);
		return CREATE_DETECT;
	}

	D3DADAPTER_IDENTIFIER9& rkD3DAdapterId=pkD3DAdapterInfo->GetIdentifier();
	if (Windowed &&
		strnicmp(rkD3DAdapterId.Driver, "3dfx", 4)==0 &&
		22 == pkD3DAdapterInfo->GetDesktopD3DDisplayModer().Format)
	{
		return CREATE_FORMAT;
	}

	if (pkD3DModeInfo->m_dwD3DBehavior==D3DCREATE_SOFTWARE_VERTEXPROCESSING)
	{
		iRet |= CREATE_NO_TNL;

		// DISABLE_NOTIFY_NOT_SUPPORT_TNL_MESSAGE
		//__WarningMessage(hWnd, CREATE_NO_TNL);
		// END_OF_DISABLE_NOTIFY_NOT_SUPPORT_TNL_MESSAGE
	}

	std::string stModeInfo;
	pkD3DModeInfo->GetString(&stModeInfo);

	//Tracen(stModeInfo.c_str());

	int ErrorCorrection = 0;

RETRY:
	ZeroMemory(&ms_d3dPresentParameter, sizeof(ms_d3dPresentParameter));
	
	ms_d3dPresentParameter.Windowed							= Windowed;
	ms_d3dPresentParameter.BackBufferWidth					= iHres;
	ms_d3dPresentParameter.BackBufferHeight					= iVres;
	ms_d3dPresentParameter.hDeviceWindow					= hWnd;
	ms_d3dPresentParameter.BackBufferCount					= m_uBackBufferCount;
	ms_d3dPresentParameter.SwapEffect						= D3DSWAPEFFECT_DISCARD;

	if (Windowed)
	{
		ms_d3dPresentParameter.BackBufferFormat				= pkD3DAdapterInfo->GetDesktopD3DDisplayModer().Format;
	}
	else
	{
		ms_d3dPresentParameter.BackBufferFormat				= pkD3DModeInfo->m_eD3DFmtPixel;
		ms_d3dPresentParameter.FullScreen_RefreshRateInHz	= iReflashRate;
	}

	ms_d3dPresentParameter.Flags							= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
	ms_d3dPresentParameter.EnableAutoDepthStencil			= TRUE;
	ms_d3dPresentParameter.AutoDepthStencilFormat			= pkD3DModeInfo->m_eD3DFmtDepthStencil;

	ms_dwD3DBehavior = pkD3DModeInfo->m_dwD3DBehavior;

	if (FAILED(ms_hLastResult = ms_lpd3d->CreateDevice(
				ms_iD3DAdapterInfo,
				D3DDEVTYPE_HAL,
				hWnd,
				// 2004. 1. 9 myevan 버텍스 프로세싱 방식 자동 선택 추가
				pkD3DModeInfo->m_dwD3DBehavior,
				&ms_d3dPresentParameter,
				&ms_lpd3dDevice)))
	{
		switch (ms_hLastResult)
		{
			case D3DERR_INVALIDCALL:
				Tracen("IDirect3DDevice.CreateDevice - ERROR D3DERR_INVALIDCALLnThe method call is invalid. For example, a method's parameter may have an invalid value.");					
				break;
			case D3DERR_NOTAVAILABLE:
				Tracen("IDirect3DDevice.CreateDevice - ERROR D3DERR_NOTAVAILABLEnThis device does not support the queried technique. ");
				break;
			case D3DERR_OUTOFVIDEOMEMORY:
				Tracen("IDirect3DDevice.CreateDevice - ERROR D3DERR_OUTOFVIDEOMEMORYnDirect3D does not have enough display memory to perform the operation");
				break;
			default:
				Tracenf("IDirect3DDevice.CreateDevice - ERROR %d", ms_hLastResult);
				break;
		}

		if (ErrorCorrection)
			return CREATE_DEVICE;
	
		// 2004. 1. 9 myevan 큰의미 없는 코드인듯.. 에러나면 표시하고 종료하자
		iReflashRate = 0;
		++ErrorCorrection;
		iRet = CREATE_REFRESHRATE;
		goto RETRY;
	}

	// Check DXT Support Info
	if(ms_lpd3d->CheckDeviceFormat(
				ms_iD3DAdapterInfo, 
				D3DDEVTYPE_HAL,
				ms_d3dPresentParameter.BackBufferFormat,
				0,
				D3DRTYPE_TEXTURE,
				D3DFMT_DXT1) == D3DERR_NOTAVAILABLE)
	{
		ms_bSupportDXT = false;
	}

	if(ms_lpd3d->CheckDeviceFormat(
				ms_iD3DAdapterInfo, 
				D3DDEVTYPE_HAL,
				ms_d3dPresentParameter.BackBufferFormat,
				0,
				D3DRTYPE_TEXTURE,
				D3DFMT_DXT3) == D3DERR_NOTAVAILABLE)
	{
		ms_bSupportDXT = false;
	}

	if(ms_lpd3d->CheckDeviceFormat(
				ms_iD3DAdapterInfo, 
				D3DDEVTYPE_HAL,
				ms_d3dPresentParameter.BackBufferFormat,
				0,
				D3DRTYPE_TEXTURE,
				D3DFMT_DXT5) == D3DERR_NOTAVAILABLE)
	{
		ms_bSupportDXT = false;
	}	

	if (FAILED((ms_hLastResult = ms_lpd3dDevice->GetDeviceCaps(&ms_d3dCaps))))
	{
		Tracenf("IDirect3DDevice.GetDeviceCaps - ERROR %d", ms_hLastResult);
		return CREATE_GET_DEVICE_CAPS2;
	}

	if (!Windowed)
		SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, iHres, iVres, SWP_SHOWWINDOW);

	//Tracef("vertex shader version : %Xn",(DWORD)ms_d3dCaps.VertexShaderVersion);

	ms_lpd3dDevice->GetViewport(&ms_Viewport);

	m_pStateManager = new CStateManager(ms_lpd3dDevice);

	D3DXCreateMatrixStack(0, &ms_lpd3dMatStack);
	ms_lpd3dMatStack->LoadIdentity();

	ms_ptVS	= CreatePTStreamVertexShader();
	ms_pntVS = CreatePNTStreamVertexShader();
	ms_pnt2VS = CreatePNT2StreamVertexShader();

	D3DXMatrixIdentity(&ms_matIdentity);
	D3DXMatrixIdentity(&ms_matView);
	D3DXMatrixIdentity(&ms_matProj);
	D3DXMatrixIdentity(&ms_matInverseView);
	D3DXMatrixIdentity(&ms_matInverseViewYAxis);
	D3DXMatrixIdentity(&ms_matScreen0);
	D3DXMatrixIdentity(&ms_matScreen1);
	D3DXMatrixIdentity(&ms_matScreen2);

	ms_matScreen0._11 = 1;
	ms_matScreen0._22 = -1;	

	ms_matScreen1._41 = 1;
	ms_matScreen1._42 = 1;

	ms_matScreen2._11 = (float) iHres / 2;
	ms_matScreen2._22 = (float) iVres / 2;
	
	D3DXCreateSphere(ms_lpd3dDevice, 1.0f, 32, 32, &ms_lpSphereMesh, NULL);
	D3DXCreateCylinder(ms_lpd3dDevice, 1.0f, 1.0f, 1.0f, 8, 8, &ms_lpCylinderMesh, NULL);

	ms_lpd3dDevice->Clear(0L, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff000000, 1.0f, 0);

	if (!__CreateDefaultIndexBufferList())
		return false;

	if (!__CreatePDTVertexBufferList())
		return false;
	
	DWORD dwTexMemSize = GetAvailableTextureMemory();

	if (dwTexMemSize < 64 * 1024 * 1024)
		ms_isLowTextureMemory = true;
	else
		ms_isLowTextureMemory = false;

	if (dwTexMemSize > 100 * 1024 * 1024)
		ms_isHighTextureMemory = true;
	else
		ms_isHighTextureMemory = false;

	if (ms_d3dCaps.TextureAddressCaps & D3DPTADDRESSCAPS_BORDER)
		GRAPHICS_CAPS_CAN_NOT_TEXTURE_ADDRESS_BORDER=false;
	else
		GRAPHICS_CAPS_CAN_NOT_TEXTURE_ADDRESS_BORDER=true;

	//D3DADAPTER_IDENTIFIER9& rkD3DAdapterId=pkD3DAdapterInfo->GetIdentifier();
	if (strnicmp(rkD3DAdapterId.Driver, "SIS", 3) == 0)
	{
		GRAPHICS_CAPS_CAN_NOT_DRAW_LINE = true;
		GRAPHICS_CAPS_CAN_NOT_DRAW_SHADOW = true;
		GRAPHICS_CAPS_HALF_SIZE_IMAGE = true;
		ms_isLowTextureMemory = true;
	}
	else if (strnicmp(rkD3DAdapterId.Driver, "3dfx", 4) == 0)
	{
		GRAPHICS_CAPS_CAN_NOT_DRAW_SHADOW = true;
		GRAPHICS_CAPS_HALF_SIZE_IMAGE = true;
		ms_isLowTextureMemory = true;
	}

	return (iRet);
}

    Matrix :

    void CCamera::SetViewMatrix()
{
	m_v3View = m_v3Target - m_v3Eye;
	D3DXVECTOR3 v3CenterRay = -m_v3View;
 	CalculateRoll();
	m_fDistance = D3DXVec3Length(&m_v3View);
	assert(m_fDistance >= 0);
	D3DXVec3Normalize(&m_v3View , &m_v3View);

    D3DXVec3Cross(&m_v3Cross, &m_v3Up, &m_v3View);
	D3DXVec3Normalize(&m_v3Cross, &m_v3Cross);

    D3DXVec3Cross(&m_v3Up, &m_v3View, &m_v3Cross);
	D3DXVec3Normalize(&m_v3Up, &m_v3Up);

	m_fPitch = D3DXVec3Dot(&m_v3Up, &D3DXVECTOR3(0.0f, 0.0f, 1.0f));// / D3DXVec2Length(&v2ViewYZ);
	if (m_fPitch >= 1)
		m_fPitch = 1;
	else if (m_fPitch <= -1)
		m_fPitch = -1;
	m_fPitch = acosf(m_fPitch);
	m_fPitch *= (180.0f / D3DX_PI);
	if ( 0 < m_v3View.z )
		m_fPitch = -m_fPitch;

	D3DXMatrixLookAtRH(&m_matView, &m_v3Eye, &m_v3Target, &m_v3Up);

	float fDeterminantD3DMatView = D3DXMatrixDeterminant(&m_matView);
    D3DXMatrixInverse(&m_matInverseView, &fDeterminantD3DMatView, &m_matView);

	m_matBillboard = m_matInverseView;
    m_matBillboard._41 = 0.0f;
    m_matBillboard._42 = 0.0f;
    m_matBillboard._43 = 0.0f;

	m_ViewRay.SetStartPoint(m_v3Target);
	m_ViewRay.SetDirection(v3CenterRay, m_fDistance);

	m_kCameraBottomToTerrainRay.SetStartPoint(m_v3Eye);
	m_kCameraFrontToTerrainRay.SetStartPoint(m_v3Eye);
	m_kCameraBackToTerrainRay.SetStartPoint(m_v3Eye);
	m_kCameraLeftToTerrainRay.SetStartPoint(m_v3Eye);
	m_kCameraRightToTerrainRay.SetStartPoint(m_v3Eye);
	m_kTargetToCameraBottomRay.SetStartPoint(m_v3Target);

	m_kCameraBottomToTerrainRay.SetDirection(-m_v3Up, 2.0f * m_fTerrainCollisionRadius);
	m_kCameraFrontToTerrainRay.SetDirection(m_v3View, 4.0f * m_fTerrainCollisionRadius);
	m_kCameraBackToTerrainRay.SetDirection(-m_v3View, m_fTerrainCollisionRadius);
	m_kCameraLeftToTerrainRay.SetDirection(-m_v3Cross, 3.0f * m_fTerrainCollisionRadius);
	m_kCameraRightToTerrainRay.SetDirection(m_v3Cross, 3.0f * m_fTerrainCollisionRadius);
	m_kTargetToCameraBottomRay.SetDirection(v3CenterRay - m_fTerrainCollisionRadius * m_v3Up,
		D3DXVec3Length(&(v3CenterRay - m_fTerrainCollisionRadius * m_v3Up)));

	m_kLeftObjectCollisionRay.SetStartPoint(m_v3Target);
	m_kTopObjectCollisionRay.SetStartPoint(m_v3Target);
	m_kRightObjectCollisionRay.SetStartPoint(m_v3Target);
	m_kBottomObjectCollisionRay.SetStartPoint(m_v3Target);

	m_kLeftObjectCollisionRay.SetDirection(v3CenterRay + m_fObjectCollisionRadius * m_v3Cross,
		D3DXVec3Length(&(v3CenterRay + m_fObjectCollisionRadius * m_v3Cross)));
	m_kRightObjectCollisionRay.SetDirection(v3CenterRay - m_fObjectCollisionRadius * m_v3Cross,
		D3DXVec3Length(&(v3CenterRay - m_fObjectCollisionRadius * m_v3Cross)));
	m_kTopObjectCollisionRay.SetDirection(v3CenterRay + m_fObjectCollisionRadius * m_v3Up,
		D3DXVec3Length(&(v3CenterRay + m_fObjectCollisionRadius * m_v3Up)));
	m_kBottomObjectCollisionRay.SetDirection(v3CenterRay - m_fObjectCollisionRadius * m_v3Up,
		D3DXVec3Length(&(v3CenterRay + m_fObjectCollisionRadius * m_v3Up)));
}

     

×
×
  • Create New...

Important Information

Terms of Use / Privacy Policy / Guidelines / We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.