Esempio n. 1
0
Sky::Sky(std::string strSkyTextureFileName, float fSkyRadius)
	:m_fSkyRadius(fSkyRadius)
{
	D3DXCreateSphere(pDxDevice, m_fSkyRadius, 160, 160, &m_pSkyMesh, 0);
	D3DXCreateCubeTextureFromFile(pDxDevice, strSkyTextureFileName.c_str(), &m_pSkyTexture);

	D3DXCreateEffectFromFile(pDxDevice, "../../Resources/shaders/SkyShader.fx", 0, 0, 0, 0, &m_pEffect, 0);

	m_hEffectTechnique	= m_pEffect->GetTechniqueByName("SkyTech");
	m_hWVPMatrix		= m_pEffect->GetParameterByName(0, "WVP");
	m_hSkyTexture		= m_pEffect->GetParameterByName(0, "tex0");

	m_pEffect->SetTechnique(m_hEffectTechnique);
	m_pEffect->SetTexture(m_hSkyTexture, m_pSkyTexture);
}
Esempio n. 2
0
	void GUIBasicEffect::Initialize()
	{
		LPD3DXBUFFER pErrors = NULL;
		HRESULT hr = D3DXCreateEffectFromFile(MyApp::GetSingleton()->GetD3DDevice(), L"Content\\Effects\\GUI\\BasicEffect.fx",
			NULL, NULL, NULL, NULL, &pEffect, &pErrors);

		#if defined( _DEBUG )
			if ( FAILED( hr ) && pErrors != NULL && pErrors->GetBufferPointer() != NULL )
				MyApp::GetSingleton()->Error(strcat("Effect Compilation Error: ", (char *)pErrors->GetBufferPointer()));
		#endif 
		if( pErrors != NULL )
			pErrors->Release();

		return;
	}
Esempio n. 3
0
int _stdcall LoadShader(const char* path) {
	if(GraphicsMode < 4) return -1;
	if(strstr(path, "..")) return -1;
	if(strstr(path, ":")) return -1;
	char buf[MAX_PATH];
	strcpy_s(buf, "data\\shaders\\");
	strcat_s(buf, path);
	for(DWORD d=0;d<shaders.size();d++) {
		if(!shaders[d].Effect) {
			if(FAILED(D3DXCreateEffectFromFile(d3d9Device, buf, 0, 0, 0, 0, &shaders[d].Effect, 0))) return -1;
			else return d;
		}
	}
	sShader shader=sShader();
	if(FAILED(D3DXCreateEffectFromFile(d3d9Device, buf, 0, 0, 0, 0, &shader.Effect, 0))) return -1;

	shader.Effect->SetFloatArray("rcpres", rcpres, 2);

	for(int i=1;i<128;i++) {
		char buf[MAX_PATH];
		const char* name;
		IDirect3DTexture9* tex;

		sprintf_s(buf, "texname%d", i);
		if(FAILED(shader.Effect->GetString(buf, &name))) break;
		sprintf_s(buf, "data\\art\\stex\\%s", name);
		if(FAILED(D3DXCreateTextureFromFileA(d3d9Device,buf,&tex))) continue;
		sprintf_s(buf, "tex%d", i);
		shader.Effect->SetTexture(buf, tex);
		shaderTextures.push_back(tex);
	}
	
	shader.ehTicks=shader.Effect->GetParameterByName(0, "tickcount");
	shaders.push_back(shader);
	return shaders.size()-1;
}
Esempio n. 4
0
HRESULT Effect::EffectCompile(){

	LPD3DXBUFFER err=NULL;
	if(FAILED(D3DXCreateEffectFromFile(GetDevice(),info.fileName.c_str(),NULL,NULL,D3DXSHADER_DEBUG,NULL,&pFX,&err))){
		// コンパイルエラーの場合はエラーを表示して終了
		if (!pFX) {
			MessageBox(
				NULL, 
				err?(LPCTSTR)err->GetBufferPointer():NULL, 
				"エフェクトファイルの読込エラー", MB_OK);
		}
		return E_FAIL;
	}
	return S_OK;
}
Esempio n. 5
0
bool CWaterRender::Setup()
{
	ID3DXBuffer *errors;
	HRESULT result = D3DXCreateEffectFromFile(g_Device,"resources/Shaders/water.fx", 0, 0, 0, 0, &m_pEffect, &errors);
	if(!CDebug::CheckForShaderErrors(errors, "CWaterRender", "water", result))
	{
		return false;
	}
	D3DXCreateTextureFromFile(g_Device,"resources/Textures/Water_NormalN.png",&tNormalN);
	D3DXCreateTextureFromFile(g_Device,"resources/Textures/Water_NormalW.png",&tNormalW);
	D3DXCreateTextureFromFile(g_Device,"resources/Textures/Waves.png",&tNormalH1);
	D3DXCreateTextureFromFile(g_Device,"resources/Textures/Foam.png",&FoamTexture);
	D3DXCreateTextureFromFile(g_Device,"resources/Textures/Foam.dds",&FoamTexture2);
	return true;
}
YAMANGDXDLL_API HRESULT ShaderImport( LPCTSTR effectFile, int id )
{
	DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE | D3DXSHADER_DEBUG | D3DXSHADER_NO_PRESHADER;

	HRESULT hr = S_OK;
	hr = D3DXCreateEffectFromFile( g_D3dDevice, effectFile, NULL, NULL, dwShaderFlags, NULL, &g_Effects[id], NULL );

	if ( FAILED( hr ) )
	{
		MessageBox( NULL, L"Effect Load Failed", effectFile, MB_OK );
		return E_FAIL;
	}

	return S_OK;
}
Esempio n. 7
0
void noisemaker::LoadEffect(){

	char *errortext;
	LPD3DXBUFFER errors;
	// load the perlin noise effect
	D3DXCreateEffectFromFile(device, "noisemakermk2.fx", 
		NULL, NULL, 0, NULL, &anim_effect, &errors );
	if (errors != NULL){
		errortext = (char*) errors->GetBufferPointer();
		MessageBox(NULL, errortext, "Textures.exe", MB_OK);		
	}
	D3DXHANDLE hTechnique;
	anim_effect->FindNextValidTechnique(NULL, &hTechnique);    
	anim_effect->SetTechnique(hTechnique);

	// and the normalmap effect
	D3DXCreateEffectFromFile(device, "normalmapgenerator.fx", 
		NULL, NULL, 0, NULL, &normalmap_effect, &errors );
	if (errors != NULL){
		errortext = (char*) errors->GetBufferPointer();
		MessageBox(NULL, errortext, "Textures.exe", MB_OK);		
	}	
	normalmap_effect->FindNextValidTechnique(NULL, &hTechnique);    
	normalmap_effect->SetTechnique(hTechnique);

	// and the noise_octaves effect
	D3DXCreateEffectFromFile(device, "noise_octaves.fx", 
		NULL, NULL, 0, NULL, &noise_octaves_effect, &errors );
	if (errors != NULL){
		errortext = (char*) errors->GetBufferPointer();
		MessageBox(NULL, errortext, "Textures.exe", MB_OK);		
	}	
	noise_octaves_effect->FindNextValidTechnique(NULL, &hTechnique);    
	noise_octaves_effect->SetTechnique(hTechnique);

}
Esempio n. 8
0
//-------------------------------------------------------------
// Name: InitDeviceObjects()
// Desc: ����̽��� ���������� �ʱ�ȭ
//       �����ӹ��� ���˰� ����̽� ������ ���ѵڿ� ȣ��
//       ���⼭ Ȯ���� �޸𸮴� DeleteDeviceObjects()���� ����
//-------------------------------------------------------------
HRESULT CMyD3DApplication::InitDeviceObjects()
{
    HRESULT hr;

	// UFO�б�
	if( FAILED( hr=m_pMesh  ->Create( m_pd3dDevice, _T("ufo.x"))))
        return DXTRACE_ERR( "LoadCar", hr );
	m_pMesh->SetFVF(m_pd3dDevice, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 );
	// �����б�
	if( FAILED( hr=m_pMeshBg->Create( m_pd3dDevice, _T("map.x"))))
        return DXTRACE_ERR( "LoadChess", hr );
        
    // �������� �ؽ�ó�� ���������� ���� �ʴ´�
	m_pMesh  ->UseMeshMaterials(FALSE);
	m_pMeshBg->UseMeshMaterials(FALSE);

	// ��Ʈ
    m_pFont->InitDeviceObjects( m_pd3dDevice );

	// ���̴� �б�
	LPD3DXBUFFER pErr;
    if( FAILED( hr = D3DXCreateEffectFromFile(
					m_pd3dDevice, "hlsl.fx", NULL, NULL, 
				D3DXSHADER_DEBUG , NULL, &m_pEffect, &pErr ) ) ){
		MessageBox( NULL, (LPCTSTR)pErr->GetBufferPointer(), "ERROR", MB_OK);
		return DXTRACE_ERR( "CreateEffectFromFile", hr );
	}
	m_hTechnique = m_pEffect->GetTechniqueByName( "TShader" );
	m_hmWVP = m_pEffect->GetParameterByName( NULL, "mWVP" );
	m_hmWLP = m_pEffect->GetParameterByName( NULL, "mWLP" );
	m_hmWLPB= m_pEffect->GetParameterByName( NULL, "mWLPB" );
	m_hvCol = m_pEffect->GetParameterByName( NULL, "vCol" );
	m_hvDir = m_pEffect->GetParameterByName( NULL, "vLightDir" );
	m_htShadowMap = m_pEffect->GetParameterByName( NULL, "ShadowMap" );

	// �������������Ʈ ����(������)
	D3DVERTEXELEMENT9 decl[] =
	{
		{0,  0, D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
		{0, 12, D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL,	0},
		{0, 24, D3DDECLTYPE_FLOAT2,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
		D3DDECL_END()
	};
	if( FAILED( hr = m_pd3dDevice->CreateVertexDeclaration( decl, &m_pDecl )))
		return DXTRACE_ERR ("CreateVertexDeclaration", hr);

    return S_OK;
}
Esempio n. 9
0
//-----------------------------------------------------------------------------
// Name: InitEffect
// Desc: This function creates an effect
//-----------------------------------------------------------------------------
void InitEffect( char* filename, LPDIRECT3DDEVICE9 device, LPD3DXEFFECT *effect )
{
	HRESULT hr;

	LPD3DXBUFFER pBufferErrors = NULL;

	WCHAR Wfilename[256];
	OutputMessage::ToWchar( filename, Wfilename );
	hr = D3DXCreateEffectFromFile( device, Wfilename, 0, 0, 0, 0, effect, &pBufferErrors );

	if( FAILED(hr) )
	{
		LPVOID pCompilErrors = pBufferErrors->GetBufferPointer();
		ERROR((char*)pCompilErrors);
	}
}
Esempio n. 10
0
//------------------------------------------------------------------------
// 
// [2011/3/23 jjuiddong]
//------------------------------------------------------------------------
BOOL CShader::Init(char *szFileName, char *szTechnique)
{
	// 쉐이더 파일 읽기
	HRESULT hr;
	LPD3DXBUFFER pErr;
	if (FAILED(hr = D3DXCreateEffectFromFile(g_pDevice, szFileName, NULL, NULL, 
		D3DXSHADER_DEBUG , NULL, &m_pEffect, &pErr))) {
			MessageBox( NULL, (LPCTSTR)pErr->GetBufferPointer(), "ERROR", MB_OK);
			//DXTRACE_ERR( "CreateEffectFromFile", hr );
			return FALSE;
	}

	m_hTechnique = m_pEffect->GetTechniqueByName( "TShader" );

	return TRUE;
}
Esempio n. 11
0
bool Shader::Load(LPDIRECT3DDEVICE9 d3ddev, const std::string& filename)
{
    ID3DXBuffer* errorlog = nullptr;
    if(FAILED(D3DXCreateEffectFromFile(d3ddev,filename.c_str(),0,0,
        D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY,0, &m_effect, &errorlog)))
    {
        std::string errorMessage("Shader " + filename + " has failed!");
        if(errorlog)
        {
            errorMessage += (char*)errorlog->GetBufferPointer();
        }
        Diagnostic::ShowMessage(errorMessage);
        return false;
    }
    return true;
}
Esempio n. 12
0
HUD::HUD(IDirect3DDevice9 *device, int width, int height)
	: Effect(device), width(width), height(height)
{

	DWORD flags = D3DXFX_NOT_CLONEABLE;

	// Load effect from file
	SDLOG(0, "Hud Effect load");
	ID3DXBuffer* errors;
	HRESULT hr = D3DXCreateEffectFromFile(device, GetDirectoryFile("dsfix\\HUD.fx"), NULL, NULL, flags, NULL, &effect, &errors);
	if(hr != D3D_OK) SDLOG(0, "ERRORS:\n %s", errors->GetBufferPointer());

	// get handles
	frameTexHandle = effect->GetParameterByName(NULL, "frameTex2D");
	opacityHandle = effect->GetParameterByName(NULL, "opacity");
}
Esempio n. 13
0
Teapot::Teapot()
{
	D3DXCreateTeapot(theDevice, &m_mesh, nullptr);
	
	ID3DXBuffer* errorBuffer;
	D3DXCreateEffectFromFile(theDevice, "Teapot.fx", 0, 0,
		D3DXSHADER_DEBUG, 0, &m_effect, &errorBuffer);

	if (errorBuffer)
	{
		Error((char*)errorBuffer->GetBufferPointer());
		errorBuffer->Release();
	}

	m_hWorldViewProj = m_effect->GetParameterByName(0, "matWorldViewProj");
}
Esempio n. 14
0
//--------------------------------------------------------------------------------------
// Create any D3D9 resources that will live through a device reset (D3DPOOL_MANAGED)
// and aren't tied to the back buffer size
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D9CreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc,
                                     void* pUserContext )
{
    HRESULT hr;

    V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) );
    V_RETURN( g_SettingsDlg.OnD3D9CreateDevice( pd3dDevice ) );

    V_RETURN( D3DXCreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
                              OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
                              L"Arial", &g_pFont9 ) );

    // Read the D3DX effect file
    WCHAR str[MAX_PATH];
    DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE | D3DXFX_LARGEADDRESSAWARE;
#ifdef DEBUG_VS
        dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
    #endif
#ifdef DEBUG_PS
        dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
    #endif
    V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"DDSWithoutD3DX.fx" ) );
    V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags,
                                        NULL, &g_pEffect9, NULL ) );

    g_hRenderScene = g_pEffect9->GetTechniqueByName( "RenderScene" );
    g_hmWorld = g_pEffect9->GetParameterByName( NULL, "g_mWorld" );
    g_hmWorldViewProjection = g_pEffect9->GetParameterByName( NULL, "g_mWorldViewProjection" );
    g_htxDiffuse = g_pEffect9->GetParameterByName( NULL, "g_txDiffuse" );

    // Create a decl for the object data.
    D3DVERTEXELEMENT9 declDesc[] =
    {
        {0,  0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
        {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
        {0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
        {0xFF,0,D3DDECLTYPE_UNUSED, 0,0,0}// D3DDECL_END 
    };
    V_RETURN( pd3dDevice->CreateVertexDeclaration( declDesc, &g_pDecl9 ) );

    // Setup the camera's view parameters
    D3DXVECTOR3 vecEye( 0.0f, 0.0f, -5.0f );
    D3DXVECTOR3 vecAt ( 0.0f, 0.0f,  0.0f );
    g_Camera.SetViewParams( &vecEye, &vecAt );

    return S_OK;
}
Esempio n. 15
0
	Shader::Shader(std::string xmlPath)
	{	
		CWsbXmlSP xml = CWsbXml::LoadXmlFile(xmlPath);
		std::string path = xml->GetElement("path")->GetString();

		_path = path;

		WCHAR bufferName[256] = {0};
		DXconvAnsiToWide(bufferName, path.c_str(), (path.length()+1));
		
		// シェーダ ファイルのロード
		LPD3DXBUFFER compilationErrors = NULL;

		HRESULT hr = D3DXCreateEffectFromFile( 
					GraphicsManager::_device, 
					bufferName, 
					NULL, 
					NULL, 
					D3DXSHADER_DEBUG, 
					NULL, 
					&_effect, 
					&compilationErrors
					);

		// ロードに失敗した場合
		if(FAILED(hr))
		{
			if(compilationErrors)	
				DXUTOutputDebugStringA((LPCSTR)compilationErrors->GetBufferPointer());
			
			SAFE_RELEASE(compilationErrors);
			return;
		}
		// ハンドルの読み込み
		_technique = _effect->GetTechniqueByName(xml->GetElement("technique")->GetString().c_str());
		_wvp = _effect->GetParameterByName(NULL, xml->GetElement("wvp")->GetString().c_str());
		_color = _effect->GetParameterByName(NULL, xml->GetElement("color")->GetString().c_str());
		_sourceTexture = _effect->GetParameterByName(NULL, xml->GetElement("srctex")->GetString().c_str());

		// 他、ロード
		for (int i = 0; i < xml->GetElementNum("handle"); i++)
		{
			// XMLからKeyを読み込みロードする
			D3DXHANDLE shaderTemporary = _effect->GetParameterByName(NULL, xml->GetElement("handle", i)->GetString().c_str());
			_handles.insert(std::make_pair(xml->GetElement("handle", i)->GetString(), shaderTemporary));
		}
	}
Esempio n. 16
0
/**
* Loads Oculus Rift shader effect files.
***/ 
void OculusRiftView::InitShaderEffects()
{
	//Currently, RiftUp DK1 and DK2 share the same shader effects
	shaderEffect[RIFTUP] = "OculusRift.fx";
	shaderEffect[OCULUS_RIFT_DK1] = "OculusRift.fx";
	shaderEffect[OCULUS_RIFT_DK1_CROPPED] = "OculusRiftCropped.fx";
	shaderEffect[OCULUS_RIFT_DK2] = "OculusRiftDK2.fx";
	shaderEffect[OCULUS_RIFT_DK2_CROPPED] = "OculusRiftDK2Cropped.fx";

	char viewPath[512];
	ProxyHelper helper = ProxyHelper();
	helper.GetPath(viewPath, "fx\\");

	strcat_s(viewPath, 512, shaderEffect[stereo_mode].c_str());

	D3DXCreateEffectFromFile(m_pActualDevice, viewPath, NULL, NULL, 0, NULL, &viewEffect, NULL);
}
Esempio n. 17
0
LPD3DXEFFECT CreateEffectFromFile(const char* filename)
{
    // Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the
    // shader debugger. Debugging vertex shaders requires either REF or software vertex
    // processing, and debugging pixel shaders requires REF.  The
    // D3DXSHADER_FORCE_*_SOFTWARE_NOOPT flag improves the debug experience in the
    // shader debugger.  It enables source level debugging, prevents instruction
    // reordering, prevents dead code elimination, and forces the compiler to compile
    // against the next higher available software target, which ensures that the
    // unoptimized shaders do not exceed the shader model limitations.  Setting these
    // flags will cause slower rendering since the shaders will be unoptimized and
    // forced into software.  See the DirectX documentation for more information about
    // using the shader debugger.
    DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;

#if defined( DEBUG ) || defined( _DEBUG )
    // Set the D3DXSHADER_DEBUG flag to embed debug information in the shaders.
    // Setting this flag improves the shader debugging experience, but still allows
    // the shaders to be optimized and to run exactly the way they will run in
    // the release configuration of this program.
    dwShaderFlags |= D3DXSHADER_DEBUG;
#endif

#ifdef DEBUG_VS
    dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
    dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif

    // Preshaders are parts of the shader that the effect system pulls out of the
    // shader and runs on the host CPU. They should be used if you are GPU limited.
    // The D3DXSHADER_NO_PRESHADER flag disables preshaders.
    bool g_bEnablePreshader = false;
    if( !g_bEnablePreshader )
        dwShaderFlags |= D3DXSHADER_NO_PRESHADER;
    LPD3DXEFFECT effect;
    // If this fails, there should be debug output as to
    // why the .fx file failed to compile
    if (FAILED(D3DXCreateEffectFromFile(GetDevice(), filename, NULL, NULL, dwShaderFlags, NULL, &effect, NULL)))
    {
        return NULL;
    }
    return effect;

}
Esempio n. 18
0
LPD3DXEFFECT cCube::LoadEffect( const char* szFileName )
{
	LPD3DXEFFECT pEffect = NULL;

	// 셰이더 로딩
	LPD3DXBUFFER		pError = NULL;			//에러 버퍼 ( 셰이더를 컴파일할때 잘못 된 문법이나 오류정보를 리턴해주는 버퍼 )
	DWORD				dwShaderFlag = 0;		//셰이더 플레그 0 

#ifdef _DEBUG
	dwShaderFlag = dwShaderFlag | D3DXSHADER_DEBUG;		//셰이더를 디버그모드로 컴파일하겠다 ( 디버그모드로 해야 잘못된 컴파일 오류가 날때 Error 버퍼에 오류정보가 들어간다 ) 
#endif

	//fx 파일로 부터 셰이더 객체 생성
	D3DXCreateEffectFromFile(
		g_pD3DDevice,				// 디바이스
		szFileName,					// 불러올 셰이더 코드 파일이름
		NULL,						// 셰이더를 컴파일할때 추가로 사용할 #define 정의 ( 일단 NULL )
		NULL,						// 셰이더를 컴파일할때 #include 지시문을 처리할때 사용할 인터페이스 플레그 ( 일단 NULL )
		dwShaderFlag,				// 셰이더 컴파일 플레그
		NULL,						// 셰이더 매개변수를 공유할 메모리풀 ( 일단 NULL )
		&pEffect,					// 로딩될 셰이더 Effect 포인터
		&pError						// 셰이더를 로딩하고 컴파일할때 문제가 생기면 해당 버퍼에 에러메시지가 들어간다 ( 성공적으로 로딩되면 NULL 이 참조된다 )
		);

	//셰이더 파일로딩에문재가 있다면..
	if( pError != NULL || pEffect == NULL ){

		//문제의 내용이 뭔지 문자열로 확인
		int size = pError->GetBufferSize();
		char* str = new char[ size ];

		//str에 버퍼에있는 내용을 저장한다.
		sprintf_s( str, size,(const char*)pError->GetBufferPointer() );
		
		OutputDebugString(str);
		//오류내용을 출력했으니 오류버퍼 해제
		SAFE_RELEASE( pError );
		SAFE_DELETE_ARRAY(str);

		return NULL;
	}

	m_pEffect = pEffect;

	return pEffect;
}
HRESULT InitFX()
{
	D3DVERTEXELEMENT9	decl[MAX_FVF_DECL_SIZE];
	// FVF를 사용해서 정점선언값을 자동으로 채워넣는다
	D3DXDeclaratorFromFVF( MYVERTEX::FVF, decl );
	// 정점선언값으로 g_pDecl을 생성한다.
	g_pd3dDevice->CreateVertexDeclaration( decl, &g_pDecl );

	// simple.FX 파일을 읽어와서 ID3DXEffect인터페이스를 생성한다.
	if( FAILED( D3DXCreateEffectFromFile( g_pd3dDevice, "shader.fx", NULL, NULL, 0, NULL, &g_pEffect, NULL ) ) )
	{
		MessageBox( NULL, "Effect Load Failed", "shader.fx", MB_OK );
		return E_FAIL;
	}

	return S_OK;
}
Esempio n. 20
0
void AmbientDiffuseDemo::buildFX()
{
    ID3DXBuffer *errors = 0;
    HR(D3DXCreateEffectFromFile(gd3dDevice, L"../src/chap10/AmbientDiffuseDemo/ambientdiffuse.fx",
                                0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
    if (errors)
        MessageBoxA(0, (char*)errors->GetBufferPointer(), 0, 0);

    mhTech                  = mFX->GetTechniqueByName("DiffuseTech");
    mhWVP                   = mFX->GetParameterByName(0, "gWVP");
    mhWorldInverseTranspose = mFX->GetParameterByName(0, "gWorldInverseTranspose");
    mhLightVecW             = mFX->GetParameterByName(0, "gLightVecW");
    mhDiffuseMtrl           = mFX->GetParameterByName(0, "gDiffuseMtrl");
    mhDiffuseLight          = mFX->GetParameterByName(0, "gDiffuseLight");
    mhAmbientMtrl           = mFX->GetParameterByName(0, "gAmbientMtrl");
    mhAmbientLight          = mFX->GetParameterByName(0, "gAmbientLight");
}
Esempio n. 21
0
void XFileDemo::buildFX()
{
	ID3DXBuffer *errors = 0;
	HR(D3DXCreateEffectFromFile(gd3dDevice, L"../src/chap14/XFileDemo/PhongDirLtTex.fx",
		0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
	if (errors)
		MessageBoxA(0, (char*)errors->GetBufferPointer(), 0, 0);

	mhTech          = mFX->GetTechniqueByName("PhongDirLtTexTech");
	mhWVP           = mFX->GetParameterByName(0, "gWVP");
	mhWorldInvTrans = mFX->GetParameterByName(0, "gWorldInvTrans");
	mhMtrl          = mFX->GetParameterByName(0, "gMtrl");
	mhLight         = mFX->GetParameterByName(0, "gLight");
	mhEyePos        = mFX->GetParameterByName(0, "gEyePosW");
	mhWorld         = mFX->GetParameterByName(0, "gWorld");
	mhTex           = mFX->GetParameterByName(0, "gTex");
}
Esempio n. 22
0
unsigned int RendererD3D::LoadShaderFile(const std::string& szFileName)
{
	// Need to remove the '.txt' and append '.fx' to the filename
	std::string shaderData;
	shaderData += szFileName;
	shaderData.replace(shaderData.find(".txt"),4,".fx");

	ID3DXBuffer *errors;

	if(FAILED(D3DXCreateEffectFromFile(m_pd3dDevice, shaderData.c_str(), NULL, NULL, 0, NULL, &m_pEffect, &errors))){
		// Failed to load shader, post the message and kill the program
		MessageBox(NULL, (LPCSTR) errors->GetBufferPointer(), "Failed to load Shader", MB_OK); 
		assert("DEAD");
		PostQuitMessage(0);
	}
	return 0;
}
Esempio n. 23
0
void DiffuseCubeDemo::buildFX()
{
	// Create the FX from a .fx file.
	ID3DXBuffer* errors = 0;
	HR(D3DXCreateEffectFromFile(gd3dDevice, "diffuse.fx", 
		0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
	if( errors )
		MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);

	// Obtain handles.
	mhTech                  = mFX->GetTechniqueByName("DiffuseTech");
	mhWVP                   = mFX->GetParameterByName(0, "gWVP");
	mhWorldInverseTranspose = mFX->GetParameterByName(0, "gWorldInverseTranspose");
	mhLightVecW             = mFX->GetParameterByName(0, "gLightVecW");
	mhDiffuseMtrl           = mFX->GetParameterByName(0, "gDiffuseMtrl");
	mhDiffuseLight          = mFX->GetParameterByName(0, "gDiffuseLight");
}
Esempio n. 24
0
/*!-----------------------------------------------------------------------------
 *@brief	シェーダーエフェクトファイル(*.fx)をロード。
 -----------------------------------------------------------------------------*/
void LoadEffectFile()
{
	LPD3DXBUFFER  compileErrorBuffer = NULL;
	//シェーダーをコンパイル。
	HRESULT hr = D3DXCreateEffectFromFile(
		g_pd3dDevice,
		"basic.fx",
		NULL,
		NULL,
		D3DXSHADER_SKIPVALIDATION,
		NULL,
		&g_pEffect,
		&compileErrorBuffer
		);
	if (FAILED(hr)) {
		MessageBox(NULL, (char*)(compileErrorBuffer->GetBufferPointer()), "error", MB_OK);
		std::abort();
	}
}
Esempio n. 25
0
void RobotArmDemo::buildFX()
{
	// Create the FX from a .fx file.
	ID3DXBuffer* errors = 0;
	HR(D3DXCreateEffectFromFile(gd3dDevice, "PhongDirLtTex.fx", 
		0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
	if( errors )
		MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);

	// Obtain handles.
	mhTech            = mFX->GetTechniqueByName("PhongDirLtTexTech");
	mhWVP             = mFX->GetParameterByName(0, "gWVP");
	mhWorldInvTrans   = mFX->GetParameterByName(0, "gWorldInvTrans");
	mhMtrl            = mFX->GetParameterByName(0, "gMtrl");
	mhLight           = mFX->GetParameterByName(0, "gLight");
	mhEyePos          = mFX->GetParameterByName(0, "gEyePosW");
	mhWorld           = mFX->GetParameterByName(0, "gWorld");
	mhTex             = mFX->GetParameterByName(0, "gTex");
}
Esempio n. 26
0
//**関数***************************************************************************
//	概要	:	初期化
//*********************************************************************************
bool CPhongShader::Init(LPCTSTR pFxName , int nType , UINT unTech)
{
	HRESULT	hr;
	hr = D3DXCreateEffectFromFile(MANAGER.GetGraph()->GetDevice(), pFxName , 
		NULL , NULL , 0 , NULL , &m_pFx , NULL);

	if(FAILED(hr))
	{
#ifdef _DEBUG
		TCHAR szMsg[512];
		_stprintf_s(szMsg , _T("シェーダ(%s)読み込みエラー"), pFxName);
		MANAGER.MsgBox(szMsg);
#endif
		return false;
	}

	struct _param {
		LPCSTR		pszName;
		D3DXHANDLE*	pHandle;
	} param[] = {
		{"WORLDVIEWPROJECTION",	&m_hMatWVP},
		{"WORLD",				&m_hMatW},
		{"CAMERAPOSITION",		&m_hCamera},
		{"MATERIALDIFFUSE",		&m_hDiffuse},
		{"MATERIALSPECULAR",	&m_hSpecular},
		{"MATERIALPOWER",		&m_hPower},
		{"MATERIALAMBIENT",		&m_hAmbient},
		{"MATERIALTEXTURE",		&m_hTexture},
		{"MATERIALTEXTUREVALID", &m_hTexEnable},
	};
	for (int i = 0; i < _countof(param); i++) {
		*param[i].pHandle =
			m_pFx->GetParameterBySemantic(NULL,
									param[i].pszName);
	}

	m_hLight = m_pFx->GetParameterByName(NULL, "light");
	m_hTech = m_pFx->GetTechnique(unTech);
	m_nType = nType;

	return true;
}
Esempio n. 27
0
//--------------------------------------------------------------------------------------
// Create any D3D9 resources that will live through a device reset (D3DPOOL_MANAGED)
// and aren't tied to the back buffer size
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc,
                                 void* pUserContext )
{
    HRESULT hr;

    CDXUTIMEEditBox::Initialize( DXUTGetHWND() );

    V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) );
    V_RETURN( g_SettingsDlg.OnD3D9CreateDevice( pd3dDevice ) );
    // Initialize the font
    V_RETURN( D3DXCreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
                              OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
                              L"Arial", &g_pFont ) );

    DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;
#if defined( DEBUG ) || defined( _DEBUG )
        dwShaderFlags |= D3DXSHADER_DEBUG;
    #endif
#ifdef DEBUG_VS
        dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
    #endif
#ifdef DEBUG_PS
        dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
    #endif

    // Read the D3DX effect file
    WCHAR str[MAX_PATH];
    V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"CustomUI.fx" ) );
    V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags,
                                        NULL, &g_pEffect, NULL ) );

    g_Mesh.Create( pd3dDevice, L"misc\\cell.x" );

    // Setup the camera's view parameters
    D3DXVECTOR3 vecEye( 0.0f, 1.5f, -7.0f );
    D3DXVECTOR3 vecAt ( 0.0f, 0.2f, 0.0f );
    D3DXVECTOR3 vecUp ( 0.0f, 1.0f, 0.0f );
    g_Camera.SetViewParams( &vecEye, &vecAt );
    D3DXMatrixLookAtLH( &g_mView, &vecEye, &vecAt, &vecUp );

    return S_OK;
}
Esempio n. 28
0
Effect *DX9Render::loadEffectFromFile(const wchar_t *file)
{
	DX9Effect *result = new DX9Effect();

	ID3DXBuffer *error = NULL;
	HRESULT hr = D3DXCreateEffectFromFile(device, file, NULL, NULL, 0, NULL, &result->effect, &error);
	if (FAILED(hr))
	{
		//log() << "Failed to create effect \"" << file << "\"\n";
		//if (error != NULL)
			//log() << (char*)(error->GetBufferPointer()) << "\n";

		delete result;
		return NULL;
	}

	result->device = device;

	return result;
}
Esempio n. 29
0
Sky::Sky(const std::string& envmapFilename, float skyRadius)
: mRadius(skyRadius)
{
	HR(D3DXCreateSphere(gd3dDevice, skyRadius, 30, 30, &mSphere, 0));
	HR(D3DXCreateCubeTextureFromFile(gd3dDevice, envmapFilename.c_str(), &mEnvMap));

	ID3DXBuffer* errors = 0;
	HR(D3DXCreateEffectFromFile(gd3dDevice, "sky.fx", 0, 0, 0, 
		0, &mFX, &errors));
	if( errors )
		MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);

	mhTech   = mFX->GetTechniqueByName("SkyTech");
	mhWVP    = mFX->GetParameterByName(0, "gWVP");
	mhEnvMap = mFX->GetParameterByName(0, "gEnvMap");

	// Set effect parameters that do not vary.
	HR(mFX->SetTechnique(mhTech));
	HR(mFX->SetTexture(mhEnvMap, mEnvMap));
}
Esempio n. 30
0
//--------------------------------------------------------------------------------------
// Create any D3D9 resources that will live through a device reset (D3DPOOL_MANAGED)
// and aren't tied to the back buffer size
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D9CreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc,
                                     void* pUserContext )
{
    HRESULT hr;

    V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) );
    V_RETURN( g_SettingsDlg.OnD3D9CreateDevice( pd3dDevice ) );

    V_RETURN( D3DXCreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
                              OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
                              L"Arial", &g_pFont9 ) );

    // Read the D3DX effect file
    WCHAR str[MAX_PATH];
    DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;

#ifdef DEBUG_VS
    dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
    dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif
#ifdef D3DXFX_LARGEADDRESS_HANDLE
    dwShaderFlags |= D3DXFX_LARGEADDRESSAWARE;
#endif

    V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"SimpleSample.fx" ) );
    V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags,
                                        NULL, &g_pEffect9, NULL ) );

    g_hmWorldViewProjection = g_pEffect9->GetParameterByName( NULL, "g_mWorldViewProjection" );
    g_hmWorld = g_pEffect9->GetParameterByName( NULL, "g_mWorld" );
    g_hfTime = g_pEffect9->GetParameterByName( NULL, "g_fTime" );

    // Setup the camera's view parameters
    D3DXVECTOR3 vecEye( 0.0f, 0.0f, -5.0f );
    D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
    g_Camera.SetViewParams( &vecEye, &vecAt );

    return S_OK;
}