Esempio n. 1
0
void Graphics::setBlendingMode(BlendingOperation source, BlendingOperation destination) {
	device->SetRenderState(D3DRS_SRCBLEND, convert(source));
	device->SetRenderState(D3DRS_DESTBLEND, convert(destination));
}
//////////////////////////////////////////////////////////////////////////
// 버텍스 버퍼 생성
//
// CreateVertexBuffer() 함수를 이용해 만들어진 버텍스 버퍼는 위치가 고정되어 있지 않다.
// 사용 할 때에는 반드시 Lock()으로 주소를 얻어 온 후, 버퍼에 내용을 써 넣고 Unlock() 해야 한다.
//
// 버텍스 버퍼나 인덱스 버퍼는 기본 시스템 메모리 외에도 디바이스 메모리(그래픽 카드 메모리)에 생성 될 수 있다.
// 대부분의 그래픽 카드에서는 이렇게 할 경우 속도가 매우 향상 된다.
//////////////////////////////////////////////////////////////////////////
HRESULT InitVB()
{
	// 삼각형을 렌더링 하기 위해 세 개의 버텍스 선언
	CUSTOMVERTEX vertices[] =
	{
		{ 150.0f, 50.0f, 0.5f, 1.0f, 0xffff0000, }, // x, y, z, rhw, color
		{ 250.0f, 250.0f, 0.5f, 1.0f, 0xff00ff00, },
		{ 50.0f, 250.0f, 0.5f, 1.0f, 0xff00ffff, },
	};

	// 버텍스 버퍼 생성
	// 3개의 사용자 버텍스를 보관할 메모리를 할당
	// FVF를 지정하여 버텍스의 형식을 지정한다
	if ( FAILED( g_pd3dDevice->CreateVertexBuffer( 
		
		// 생성 할 버텍스 버퍼의 바이트 단위 크기
		3 * sizeof( CUSTOMVERTEX ),
		
		// 버텍스 버퍼 종류, 처리 방식(SW, HW) 지정
		0,
		
		// 커스텀 버텍스 구조체 FVF 플래그 값
		D3DFVF_CUSTOMVERTEX,
		
		// 버텍스 버퍼가 저장 될 메모리의 위치(그래픽 카드, 시스템 메모리)와 관리 방식
		D3DPOOL_DEFAULT,
		
		// 리턴 받을 버텍스 버퍼 변수
		&g_pVB,
		
		// 예약 되었음
		NULL
		
		) ) )
	{
		return E_FAIL;
	}

	// 버텍스 버퍼를 값으로 채운다. 
	// 버텍스 버퍼의 Lock()함수를 호출하여 포인터를 가져온다.
	VOID* pVertices;
	if ( FAILED( g_pVB->Lock( 

		// Lock 버퍼 시작점
		// 다음 인자와 함께 모두 0이면 전체 버퍼
		0,
		
		// Lock을 할 버퍼 크기
		// 이전 인자와 함께 모두 0이면 전체 버퍼
		sizeof( vertices ),
		
		// Lock으로 받아오는 메모리 영역의 포인터를 담을 변수
		(void**)&pVertices,
		
		// Lock을 수행할 때 함께 사용할 플래그
		0
		
		) ) )
	{
		return E_FAIL;
	}
	memcpy( pVertices, vertices, sizeof( vertices ) );
	
	// 반드시 Unlock 해야 한다. Unlock을 하지 않을 경우 그래픽카드가 다운 될 수 있음! - 교재에서
	//
	// 교수님 말씀에 따르면 실제 해 봐도 다운이 되지 않는다고 함
	g_pVB->Unlock();
	
	return S_OK;
}
Esempio n. 3
0
//-------------------------------------------------------------
// ȭ�鷻��
//-------------------------------------------------------------
void CBigSquare::Render( LPDIRECT3DDEVICE9 pd3dDevice )
{
	pd3dDevice->SetFVF( FVF );
	pd3dDevice->SetStreamSource( 0, m_pVB, 0, sizeof(SHADOWVERTEX));
	pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );
}
Esempio n. 4
0
// `使用Direct3D9來繪圖`
void RenderFrameDX9(void)
{
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
	// `消除畫面`
	device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
	// `開始下繪圖指令`
	device->BeginScene(); 
	// `設定資料格式`
	device->SetFVF(D3DFVF_XYZ | D3DFVF_NORMAL);
	// `套用shader`
	device->SetVertexShader(g_pSelected_VS);
	device->SetPixelShader(g_pVertexColor_PS);
	// `設定光源`
	SetupLightingDX9();
	// `設定轉換矩陣`
	Matrix4x4 world_view_proj_matrix = g_world_matrix * g_view_proj_matrix;
	device->SetVertexShaderConstantF(0, &world_view_proj_matrix[0][0], 4);
	device->SetVertexShaderConstantF(4, &g_world_matrix[0][0], 4);
	// `鏡頭位置, 計算Specular會用到.`
	device->SetVertexShaderConstantF(8, &g_eye[0], 1);
	// `畫出格子`
	device->DrawIndexedPrimitiveUP(D3DPT_TRIANGLESTRIP, 0, g_iNumGridVertices, g_iNumGridTriangles, 
		g_pGridIndices, D3DFMT_INDEX16, g_pGridVertices, sizeof(Vertex_V3N3) );
	// `宣告所有的繪圖指令都下完了`
	device->EndScene(); 
	// `把背景backbuffer的畫面呈現出來`
	device->Present( NULL, NULL, NULL, NULL );
}
ID3D11Texture2D * 
#endif
TextureGPU::gfxLoadDDSTexture(char *filename, bool genMips /*= true*/)
{	
	DDS::DDSTextureInSystemMemory dds;
	uint32_t test =  loadDDSIntoSystemMemory(filename,&dds);
	if(test==false) 
	{
		printf("failed to load\n");
		exit(0);
	}
	
	bool haveMips = dds.mips > 1;
	bool needToGenerateMips = !haveMips && genMips;
	bool willHaveMips = haveMips || genMips;

	if (false)
	{
		int32_t w = dds.width;
		int32_t h = dds.height;

		for (uint32_t i = 0; i < dds.mips; i++)
		{
			unsigned char r = i % 3 ? 0x00 : 0xFF;
			unsigned char g = (i+2) % 3 ? 0x00 : 0xFF;
			unsigned char b = (i+1) % 3 ? 0x00 : 0xFF;

		
			if (dds.uncompressedFormat && dds.components == 4)
			{	
				unsigned char *data = dds.image[0].pixels[i];
				for (int y = 0; y < h; y++)
					for (int x = 0; x < w; x++)
					{
						unsigned char solid = ((x % 8) > 3) ^ ((y % 8) > 3); 
						*data++ = b * solid;
						*data++ = g * solid;
						*data++ = r * solid;
						*data++ = 0;
					}
			}

			// we use componets == 3 becasue on IOS we dont have GL_BGR flag at all. event to use is as temp variable for storing dds format
			if (dds.uncompressedFormat && dds.components == 3)
			{
				unsigned char *data = dds.image[0].pixels[i];
				for (int y = 0; y < h; y++)
					for (int x = 0; x < w; x++)
					{
						*data++ = r;
						*data++ = g;
						*data++ = b;
					}
			}
			w/=2; h/=2;
			if (w == 0) w = 1;
			if (h == 0) h = 1;
		}
	}

	assert(m_samplerState != SamplerState_INVALID);

	SamplerState &ss = SamplerStateManager::getInstance()->getSamplerState(m_samplerState);

	if (willHaveMips)
	{
		//check that we want t use existing mips
		if (!ss.needsMipMaps())
		{
			PEWARN("Mipmap filtering is disabled while mipams exist and are loaded. Texture: %s", filename);
		}
	}
	else
	{
		//check that we dont want a value that assumes mip map existance
		if (ss.needsMipMaps())
		{
			PEWARN("Trying to enable mip map filtering when no mipmaps exist. Texture: %s", filename);
		}
	}
	
	int32_t w = dds.width;
	int32_t h = dds.height;

	#if APIABSTRACTION_D3D9

	D3D9Renderer *pD3D9Renderer = static_cast<D3D9Renderer *>(m_pContext->getGPUScreen());
	LPDIRECT3DDEVICE9 pDevice = pD3D9Renderer->m_pD3D9Device;

	//choose api format best suited for loaded texture
	D3DFORMAT destApiFormat = D3DFMT_UNKNOWN;
	if (dds.compressedFormat)
	{
		assert(!"Dont support compressed textures yet!");
	}
	else
	{
		if (dds.components == 1)
		{
			if (dds.uncompressedFormat == DDSF_L)
				destApiFormat = D3DFMT_L8;
			else
				assert(!"Unknown format!");
		}
		else if (dds.components == 3)
		{
			assert(!"Need to add support for this format!");
		}
		else if (dds.components == 4)
		{
			if (dds.uncompressedFormat == DDSF_RGBA)
				destApiFormat = D3DFMT_A8R8G8B8;
			else if  (dds.uncompressedFormat == DDSF_RGB)
				destApiFormat = D3DFMT_X8R8G8B8;
		}
		else
		{
			assert(!"Unknown texture format!");
		}
	}

	if (!destApiFormat)
		return NULL;

	IDirect3DTexture9 * pTexture = NULL;
	
	pDevice->CreateTexture(
		dds.width,
		dds.height,
		/*Levels = 0 - generate space for all mips, otherwise use provided number*/
		haveMips ? 0 : 1, // if we have source mipmaps set to 0 (will have mips) otherwise set to 1 becasue mips will be generated on gpu memory texture)
		0, // potentially could use D3DUSAGE_AUTOGENMIPMAP on a gpu texture, not on SYSTEMMEM, 
		destApiFormat,
		D3DPOOL_SYSTEMMEM, // set it to sys mem to be able to set pixels // D3DPOOL_DEFAULT,
		&pTexture, // result
		NULL); // set to null	

	printf("file %s dds surfaces %d mips %d w %d h %d \n",filename,dds.surfaces,dds.mips,w,h);
	if(dds.surfaces!=1)	//its a cube map 
	{
		printf("ERROR: this is a cubemap\n");
		exit(0);
	}

	if(dds.compressedFormat == FOURCC_DXT1) printf("FOURCC_DXT1\n");
	if(dds.compressedFormat == FOURCC_DXT3) printf("FOURCC_DXT3\n");
	if(dds.compressedFormat == FOURCC_DXT5) printf("FOURCC_DXT5\n");

	D3DFORMAT destGpuFormatEnum = (D3DFORMAT)(DDS::getDestGPUFormatFromComponents(dds.components));

	D3DFORMAT sourceCpuFormatEnum = (D3DFORMAT)(DDS::getSourceCPUFormatFromComponents(dds.components));

	//load a compressed texture
	if(dds.compressedFormat)
	{
		assert(!"Compressed textures are not yet supported!");
	}
	else // load a non compressed texture
	{

		for (uint32_t i = 0; i < dds.mips; i++)
		{
			IDirect3DSurface9 *pSurface = NULL;
			HRESULT hr = pTexture->GetSurfaceLevel(i, &pSurface);
			assert(SUCCEEDED(hr));

			D3DLOCKED_RECT lockedRect;
			hr = pSurface->LockRect(&lockedRect, NULL, 0);
			assert(SUCCEEDED(hr));

			unsigned char *data = dds.image[0].pixels[i];
			char *destData = (char*)(lockedRect.pBits);
			for (int y = 0; y < h; y++)
			{
				memcpy(&destData[lockedRect.Pitch * y], &data[dds.components * w * y], dds.components * w);
            }
			hr = pSurface->UnlockRect();
			assert(SUCCEEDED(hr));

			w/=2; h/=2;
			if (w == 0) w = 1;
			if (h == 0) h = 1;
		} 
		//restore to default
	}

	free(dds.buffer); // at this point the file buffer is no longer needed

	int d3dUsage = 0;
#if PE_PLAT_IS_XBOX360
	if (needToGenerateMips)
		PEWARN("On XBOX 360 we can't autogen mipmaps!\n");
#else
	d3dUsage = needToGenerateMips ? D3DUSAGE_AUTOGENMIPMAP: 0; // potentially could use D3DUSAGE_AUTOGENMIPMAP, but we do not want to support it now, since we only support mipmaps that are in dds already
#endif

	//create GPU texture that wills tore the data
	IDirect3DTexture9 *pDestTexture = NULL;
	pDevice->CreateTexture(
		dds.width,
		dds.height,
		willHaveMips ? 0 : 1, // 0: will create mipmap surfaces too
		d3dUsage,
		destApiFormat,
		D3DPOOL_DEFAULT,
		&pDestTexture, // result
		NULL); // set to null	

#if PE_PLAT_IS_XBOX360
	PEASSERT(false, "Right now we load textures on xbox360 trhough helper in d3dx. Need some reasearch to see how to load it ourselves from raw data and update the texture");
#else
	pDevice->UpdateTexture(pTexture, pDestTexture);
#endif

	pTexture->Release(); // release sys memory texture

	return pDestTexture;	// return the texture name

#else
	//choose api format best suited for loaded texture
	DXGI_FORMAT destApiFormat = DXGI_FORMAT_UNKNOWN;
	if (dds.compressedFormat)
	{
		assert(!"Dont support compressed textures yet!");
	}
	else
	{
		if (dds.components == 1)
		{
			if (dds.uncompressedFormat == DDSF_L)
				destApiFormat = DXGI_FORMAT_R8_UNORM;
			else
				assert(!"Unknown format!");
		}
		else if (dds.components == 3)
		{
			assert(!"Need to add support for this format!");
		}
		else if (dds.components == 4)
		{
			if (dds.uncompressedFormat == DDSF_RGBA)
				destApiFormat = DXGI_FORMAT_B8G8R8A8_UNORM;
			else if  (dds.uncompressedFormat == DDSF_RGB)
				destApiFormat = DXGI_FORMAT_B8G8R8X8_UNORM;
		}
		else
		{
			assert(!"Unknown texture format!");
		}
	}

	if (!destApiFormat)
		return NULL;

	ID3D11Texture2D* pTexture = NULL;
	
	D3D11_TEXTURE2D_DESC desc;
    desc.Width = dds.width;
    desc.Height = dds.height;
    desc.MipLevels = willHaveMips ? 0 : 1; 
    desc.ArraySize = 1;
    desc.Format = destApiFormat;
    desc.SampleDesc.Count = 1;
    desc.SampleDesc.Quality = 0;
    desc.Usage = D3D11_USAGE_IMMUTABLE; // immutable since data wont change
    desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
    desc.CPUAccessFlags = 0;
    desc.MiscFlags = 0;

	D3D11_SUBRESOURCE_DATA datas[32];
	//in case mips are already loaded (and not generated) we need to pass in array of the datas
	for (uint32_t i = 0; i < dds.mips; i++)
	{
		D3D11_SUBRESOURCE_DATA &data = datas[i];
		data.pSysMem = dds.image[0].pixels[/*mip=*/i];
		data.SysMemPitch = dds.components * w;
		data.SysMemSlicePitch = 0; // unused since 2d texture

		w/=2; h/=2;
		if (w == 0) w = 1;
		if (h == 0) h = 1;
	}

	D3D11Renderer *pD3D11Renderer = static_cast<D3D11Renderer *>(m_pContext->getGPUScreen());
	ID3D11Device *pDevice = pD3D11Renderer->m_pD3DDevice;
	ID3D11DeviceContext *pDeviceContext = pD3D11Renderer->m_pD3DContext;


	pDevice->CreateTexture2D(
		&desc,
		datas,
		&pTexture);
	
	return pTexture;
#endif

}
Esempio n. 6
0
 /* =============== */
 virtual void leave ()
 {
     m_devcs->EndScene();
 }
Esempio n. 7
0
bool ReadModelFile( const string &fileName, LPDIRECT3DVERTEXBUFFER9 &vtxBuff, int &vtxSize,  LPDIRECT3DINDEXBUFFER9 &idxBuff, int &faceSize )
{
	using namespace std;
	ifstream fin(fileName.c_str());
	if (!fin.is_open())
		return false;

	string vtx, vtx_eq;
	int numVertices;
	fin >> vtx >> vtx_eq >> numVertices;

	if (numVertices <= 0)
		return  false;

	vtxSize = numVertices;

	// 버텍스 버퍼 생성.
	if (FAILED(g_pDevice->CreateVertexBuffer( numVertices * sizeof(Vertex),
		D3DUSAGE_WRITEONLY, Vertex::FVF,
		D3DPOOL_MANAGED, &vtxBuff, NULL)))
	{
		return false;
	}

	// 버텍스 버퍼 초기화.
	Vertex* vertices;
	if (FAILED(vtxBuff->Lock( 0, sizeof(Vertex), (void**)&vertices, 0)))
		return false;
	float num1, num2, num3;
	for (int i = 0; i < numVertices; i++)
	{
		fin >> num1 >> num2 >> num3;
		vertices[i] = Vertex(num1, num2, num3);
	}
	vtxBuff->Unlock();


	string norm, norm_eq;
	int numNormal;
	fin >> norm >> norm_eq >> numNormal;

	if (numNormal <= 0)
		return false;

	if (FAILED(vtxBuff->Lock( 0, sizeof(Vertex), (void**)&vertices, 0)))
		return false;
	for (int i = 0; i < numVertices; i++)
	{
		fin >> num1 >> num2 >> num3;
		vertices[i].n = Vector3(num1, num2, num3);
	}
	vtxBuff->Unlock();


	string idx, idx_eq;
	int numIndices;
	fin >> idx >> idx_eq >> numIndices;

	if (numIndices <= 0)
		return false;

	faceSize = numIndices;

	if (FAILED(g_pDevice->CreateIndexBuffer(numIndices*3*sizeof(WORD), 
		D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX16,
		D3DPOOL_MANAGED,
		&idxBuff, NULL)))
	{
		return false;
	}

	WORD *indices = NULL;
	idxBuff->Lock(0, 0, (void**)&indices, 0);
	int num4, num5, num6;
	for (int i = 0; i < numIndices*3; i+=3)
	{
		fin >> num4 >> num5 >> num6;
		indices[ i] = num4;
		indices[ i+1] = num5;
		indices[ i+2] = num6;	
	}
	idxBuff->Unlock();

	//ComputeNormals(vtxBuff, vtxSize, idxBuff, faceSize);
	return true;
}
int	 RGetApproxVMem()		{ if(g_pd3dDevice==0) return 0; return g_pd3dDevice->GetAvailableTextureMem()*0.5f;}
Esempio n. 9
0
 /* =============== */
 virtual void enter ()
 {
     m_devcs->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
     m_devcs->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
     m_devcs->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
 }
Esempio n. 10
0
bool InitVertexBuffer()
{
	HRESULT hr;
	ID3DXBuffer *adjBuff = NULL;
	ID3DXBuffer *mtrlBuff = NULL;
	DWORD numMtrls = 0;

	// 메쉬 정보 로드
	hr = D3DXLoadMeshFromXA( "../../media/bigship1.x", D3DXMESH_MANAGED, 
		g_pDevice, &adjBuff, &mtrlBuff, 0, &numMtrls, &g_pMesh );
	if (FAILED(hr))
		return false;

	/////////////////////////////////////////////////////////////////////////////
	// 매터리얼 설정
	if( mtrlBuff && numMtrls > 0 )
	{
		D3DXMATERIAL *mtrls = (D3DXMATERIAL*)mtrlBuff->GetBufferPointer();

		for( int i=0; i < (int)numMtrls; ++i )
		{
			mtrls[ i].MatD3D.Ambient = mtrls[ i].MatD3D.Diffuse;
			g_Mtrls.push_back( mtrls[ i].MatD3D );

			if( mtrls[ i].pTextureFilename )
			{
				IDirect3DTexture9 *tex = NULL;
				string filePath = "../../media/";
				filePath += mtrls[ i].pTextureFilename;
				D3DXCreateTextureFromFileA( g_pDevice, filePath.c_str(), &tex );
				g_Texture.push_back( tex );
			}
			else
			{
				g_Texture.push_back( 0 );
			}
		}
	}
	mtrlBuff->Release();

	// 메쉬 최적화
	hr = g_pMesh->OptimizeInplace( 
		D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE, 
		(DWORD*)adjBuff->GetBufferPointer(), (DWORD*)adjBuff->GetBufferPointer(), 0, 0 );

	if (FAILED(hr))
		return false;

	// 프로그레시브 메쉬 생성.
	hr = D3DXGeneratePMesh(g_pMesh, (DWORD*)adjBuff->GetBufferPointer(), 0, 0, 1, 
		D3DXMESHSIMP_FACE, &g_pPMesh );
	g_pMesh->Release();
	g_pMesh = NULL;
	adjBuff->Release();
	if (FAILED(hr))
		return false;

	//DWORD maxFaces = g_pPMesh->GetMaxFaces();
	//g_pPMesh->SetNumFaces( maxFaces );




	D3DXCOLOR color(1,1,1,1);
	ZeroMemory(&g_Light, sizeof(g_Light));
	g_Light.Type = D3DLIGHT_DIRECTIONAL;
	g_Light.Ambient = color * 0.4f;
	g_Light.Diffuse = color;
	g_Light.Specular = color * 0.6f;
	g_Light.Direction = *(D3DXVECTOR3*)&Vector3(0,-1,0);	



	Matrix44 V;
	Vector3 camPos(0,0,-20);
	Vector3 lookAtPos(0,0,0);
	Vector3 dir = lookAtPos - camPos;
	dir.Normalize();
	V.SetView(camPos, dir, Vector3(0,1,0));
	g_pDevice->SetTransform(D3DTS_VIEW, (D3DXMATRIX*)&V);

	Matrix44 proj;
	proj.SetProjection(D3DX_PI * 0.5f, (float)WINSIZE_X / (float) WINSIZE_Y, 1.f, 1000.0f) ;
	g_pDevice->SetTransform(D3DTS_PROJECTION, (D3DXMATRIX*)&proj) ;

	g_pDevice->SetLight(0, &g_Light); // 광원 설정.
	g_pDevice->LightEnable(
		0, // 활성화/ 비활성화 하려는 광원 리스트 내의 요소
		true); // true = 활성화 , false = 비활성화

	g_pDevice->SetRenderState(D3DRS_NORMALIZENORMALS, true);
	g_pDevice->SetRenderState(D3DRS_SPECULARENABLE, true);

	return true;
}
Esempio n. 11
0
// @brief  : 描画が無効のときの挙動
//--------------------------------------------------------------------
void DirectionalLightDx9::OnDisable( void )
{
    LPDIRECT3DDEVICE9 device = DirectX9::Instance().Device;
    device->LightEnable(m_Index,FALSE);
}
void clsDXDevice::CreateBackBuffer(LPDIRECT3DDEVICE9 ldd)
{
	ldd->GetBackBuffer(0,0,D3DBACKBUFFER_TYPE_MONO,&backbuffer);
}
void DrawBillboard()
{
	// 알파채널을 사용해서 투명텍스처 효과를 낸다
	g_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
	g_pd3dDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
	g_pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
	g_pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
	g_pd3dDevice->SetRenderState( D3DRS_ALPHAREF, 0x08 );
	g_pd3dDevice->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );

	struct MYVERTEX
	{
		enum { FVF = D3DFVF_XYZ | D3DFVF_TEX1 };
		float px, py, pz;
		float tu, tv;
	};

	// 빌보드 정점
	MYVERTEX vtx[4] =
	{
		{ -1, 0, 0, 0, 1 },
		{ -1, 4, 0, 0, 0 },
		{ 1, 0, 0, 1, 1 },
		{ 1, 4, 0, 1, 0 }
	};
	D3DXMATRIXA16	matBillboard;
	D3DXMatrixIdentity( &matBillboard );

	// 0번 텍스처에 빌보드 텍스처를 올린다
	g_pd3dDevice->SetTexture( 1, NULL );
	g_pd3dDevice->SetFVF( MYVERTEX::FVF );

	if ( g_bBillboard )
	{
		// Y축 회전행렬은 _11, _13, _31, _33번 행렬에 회전값이 들어간다
		// 카메라의 Y축 회전행렬값을 읽어서 역행렬을 만들면 X,Z축이 고정된
		// Y축 회전 빌보드 행렬을 만들수 있다
		matBillboard._11 = g_pCamera->GetViewMatrix()->_11;
		matBillboard._13 = g_pCamera->GetViewMatrix()->_13;
		matBillboard._31 = g_pCamera->GetViewMatrix()->_31;
		matBillboard._33 = g_pCamera->GetViewMatrix()->_33;
		D3DXMatrixInverse( &matBillboard, NULL, &matBillboard );
	}

	// 빌보드의 좌표를 바꿔가며 찍는다
	for ( int z = 0; z <= 40; z += 5 )
	{
		for ( int x = 0; x <= 40; x += 5 )
		{
			matBillboard._41 = static_cast<float>( x - 20 );
			matBillboard._42 = 0;
			matBillboard._43 = static_cast<float>( z - 20 );
			g_pd3dDevice->SetTexture( 0, g_pTexBillboard[( x + z ) % 4] );
			g_pd3dDevice->SetTransform( D3DTS_WORLD, &matBillboard );
			g_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, vtx, sizeof( MYVERTEX ) );
		}
	}

	g_pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
	g_pd3dDevice->SetTransform( D3DTS_WORLD, &g_matWorld );
}
Esempio n. 14
0
//=============================================================================
// 描画処理
//=============================================================================
void DrawModel(LPDIRECT3DDEVICE9 pDevice)
{
	//LPDIRECT3DDEVICE9 pDevice = GetDevice();
	
	D3DXMATERIAL * 	pD3DXMat;
	D3DMATERIAL9	matDef;
	
	D3DXMATRIX mtxScale,mtxRot,mtxTrans;
	
	pDevice->SetFVF(Player.pD3DXMeshModel->GetFVF());

	//ワールドマトリクスの初期化
	D3DXMatrixIdentity(&Player.mtxWorld);	// Identity:単位○○

	//現在のマテリアルを取得
	pDevice->GetMaterial(&matDef);
	
	// スケールを反映
	D3DXMatrixScaling(
		&mtxScale,		//格納先
		Player.scaleModel.x,
		Player.scaleModel.y,
		Player.scaleModel.z
	);
	D3DXMatrixMultiply(
		&Player.mtxWorld,	//格納先(A*B)
		&Player.mtxWorld,	//A
		&mtxScale		//B
	);

	// 回転を反映
	D3DXMatrixRotationYawPitchRoll(
		&mtxRot,		//格納先
		Player.rotModel.y,	//ヨー(左右)
		Player.rotModel.x,	//ピッチ(前後)
		Player.rotModel.z	//ロール(回転)
	);
	D3DXMatrixMultiply(
		&Player.mtxWorld,	//格納先(A*B)
		&Player.mtxWorld,	//A
		&mtxRot			//B
	);

	// 移動を反映
	D3DXMatrixTranslation(
		&mtxTrans,		//格納先
		Player.posModel.x,	//
		Player.posModel.y,	//
		Player.posModel.z	//
	);
	D3DXMatrixMultiply(
		&Player.mtxWorld,	//格納先(A*B)
		&Player.mtxWorld,	//A
		&mtxTrans		//B
	);

	//ワールドマトリクスの設定
	pDevice->SetTransform(D3DTS_WORLD,&Player.mtxWorld);

	//マテリアル情報に対するポインタを取得
	pD3DXMat = (D3DXMATERIAL*)Player.pD3DXBuffMatModel->GetBufferPointer();
	

	for(int nCntMat = 0; nCntMat < (int)Player.nNumMatModel; nCntMat ++){
		//マテリアルの設定
		pDevice->SetMaterial(&pD3DXMat[nCntMat].MatD3D);
		//テクスチャの設定
		pDevice->SetTexture(0, Player.pMeshTex[nCntMat]);
		//描画
		Player.pD3DXMeshModel->DrawSubset(nCntMat);
	}
	
	//マテリアルを元に戻す
	pDevice->SetMaterial(&matDef);
}
Esempio n. 15
0
 /* =============== */
 virtual void leave ()
 {
     for (uint_t idx = m_enter; idx < m_leave; idx += 3)
         m_devcs->SetTextureStageState(m_value[idx], (D3DTEXTURESTAGESTATETYPE)m_value[idx + 1], m_value[idx + 2]);
 }
Esempio n. 16
0
 /* =============== */
 virtual void leave ()
 {
     m_devcs->SetRenderState(D3DRS_NORMALIZENORMALS, FALSE);
     m_devcs->SetRenderState(D3DRS_LIGHTING, FALSE);
 }
Esempio n. 17
0
 /* =============== */
 virtual void enter ()
 {
     m_devcs->Clear(0, NULL, m_flags, m_color, 1.0f, 0);
     m_devcs->BeginScene();
     m_devcs->SetTransform(D3DTS_VIEW, &m_main3d->get_tran()->view);
 }
Esempio n. 18
0
 /* =============== */
 virtual void enter ()
 {
     m_devcs->SetRenderState(D3DRS_SPECULARENABLE, TRUE);
 }
Esempio n. 19
0
 /* =============== */
 virtual void enter ()
 {
     m_devcs->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
     m_devcs->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
 }
Esempio n. 20
0
 /* =============== */
 virtual void leave ()
 {
     m_devcs->SetRenderState(D3DRS_SPECULARENABLE, FALSE);
 }
Esempio n. 21
0
int APIENTRY WinMain(HINSTANCE hInstance, 
	HINSTANCE hPrevInstance, 
	LPSTR lpCmdLine, 
	int nCmdShow)
{
	wchar_t className[32] = L"Sample";
	wchar_t windowName[32] = L"Sample";

	//윈도우 클레스 정보 생성
	//내가 이러한 윈도를 만들겠다 라는 정보
	WNDCLASS WndClass;
	WndClass.cbClsExtra = 0;			//윈도우에서 사용하는 여분의 메모리설정( 그냥 0 이다  신경쓰지말자 )
	WndClass.cbWndExtra = 0;			//윈도우에서 사용하는 여분의 메모리설정( 그냥 0 이다  신경쓰지말자 )
	WndClass.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);		//윈도우 배경색상
	WndClass.hCursor = LoadCursor( NULL, IDC_ARROW );			//윈도우의 커서모양 결정
	WndClass.hIcon = LoadIcon( NULL, IDI_APPLICATION );		//윈도우아이콘모양 결정
	WndClass.hInstance = hInstance;				//프로그램인스턴스핸들 
	WndClass.lpfnWndProc = (WNDPROC)WndProc;			//윈도우 프로시져 함수 포인터
	WndClass.lpszMenuName = NULL;						//메뉴이름 없으면 NULL
	WndClass.lpszClassName = className;				//지금 작성하고 있는 윈도우 클레스의 이름
	WndClass.style	 = CS_HREDRAW | CS_VREDRAW;	//윈도우 그리기 방식 설정 ( 사이즈가 변경될때 화면갱신 CS_HREDRAW | CS_VREDRAW )

	//위에서 작성한 윈도우 클레스정보 등록
	RegisterClass( &WndClass );

	//윈도우 생성
	//생성된 윈도우 핸들을 전역변수 g_hWnd 가 받는다.
	HWND hWnd = CreateWindow(
		className,				//생성되는 윈도우의 클래스이름
		windowName,				//윈도우 타이틀바에 출력되는 이름
		WS_OVERLAPPEDWINDOW,	//윈도우 스타일 WS_OVERLAPPEDWINDOW
		WINPOS_X,				//윈도우 시작 위치 X 
		WINPOS_Y,				//윈도우 시작 위치 Y
		WINSIZE_X,				//윈도우 가로 크기 ( 작업영역의 크기가 아님 )
		WINSIZE_Y,				//윈도우 세로 크기 ( 작업영역의 크기가 아님 )
		GetDesktopWindow(),		//부모 윈도우 핸들 ( 프로그램에서 최상위 윈도우면 NULL 또는 GetDesktopWindow() )
		NULL,					//메뉴 ID ( 자신의 컨트롤 객체의 윈도우인경우 컨트롤 ID 가 된	
		hInstance,				//이 윈도우가 물릴 프로그램 인스턴스 핸들
		NULL					//추가 정보 NULL ( 신경끄자 )
		);

	//윈도우를 정확한 작업영역 크기로 맞춘다
	RECT rcClient = { 0, 0, WINSIZE_X, WINSIZE_Y };
	AdjustWindowRect( &rcClient, WS_OVERLAPPEDWINDOW, FALSE );	//rcClient 크기를 작업 영영으로 할 윈도우 크기를 rcClient 에 대입되어 나온다.

	//윈도우 크기와 윈도우 위치를 바꾸어준다.
	SetWindowPos( hWnd, NULL, 0, 0, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top, 
		SWP_NOZORDER | SWP_NOMOVE );

	if (!InitDirectX(hWnd))
	{
		return 0;
	}

	InitVertexBuffer();

	ShowWindow( hWnd, nCmdShow );

	//메시지 구조체
	MSG msg;		
	ZeroMemory( &msg, sizeof( MSG ) );

	int oldT = GetTickCount();
	while (msg.message != WM_QUIT)
	{
		//PeekMessage 는 메시지 큐에 메시지가 없어도 프로그램이 멈추기 않고 진행이 된다.
		//이때 메시지큐에 메시지가 없으면 false 가 리턴되고 메시지가 있으면 true 가 리턴이된다.
		if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
		{
			TranslateMessage( &msg ); //눌린 키보드 의 문자를 번역하여 WM_CHAR 메시지를 발생시킨다.
			DispatchMessage( &msg );  //받아온 메시지 정보로 윈도우 프로시져 함수를 실행시킨다.
		}
		else
		{
			const int curT = GetTickCount();
			const int elapseT = curT - oldT;
			if (elapseT > 15)
			{
				oldT = curT;
				Render(elapseT);
			}
		}
	}

	if (g_pDevice)
		g_pDevice->Release();
	if (g_pVB)
		g_pVB->Release();
	if (g_pIB)
		g_pIB->Release();
	return 0;
}
Esempio n. 22
0
 /* =============== */
 virtual void enter ()
 {
     m_devcs->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
     m_devcs->SetRenderState(D3DRS_ALPHAREF, m_value);
     m_devcs->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);
 }
Esempio n. 23
0
static void SetupLightingDX9(void)
{
	// `取得Direct3D9裝置`
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();

	int base = 12;
	Vector4 vShininess = g_fMaterialShininess;
	Vector4 vAmbient, vDiffuse, vSpecular, vSpotLightCoeff;
	// `設定環境光`
	device->SetVertexShaderConstantF(base, &g_vAmbientLight[0], 1);

	// `設定光源`
	switch(g_iSelectedLight)
	{
		// `方向光`
	default:
	case 0:
		g_pSelected_VS = g_pDirLight_VS;

		vAmbient = g_vMaterialAmbient * g_Lights[0].m_vAmbientColor;
		vDiffuse = g_vMaterialDiffuse * g_Lights[0].m_vDiffuseColor;
		vSpecular = g_vMaterialSpecular * g_Lights[0].m_vSpecularColor;

		device->SetVertexShaderConstantF(base + 1, &g_Lights[0].m_vDirection.x, 1);
		device->SetVertexShaderConstantF(base + 2, &vAmbient.x, 1);
		device->SetVertexShaderConstantF(base + 3, &vDiffuse.x, 1);
		device->SetVertexShaderConstantF(base + 4, &vSpecular.x, 1);
		device->SetVertexShaderConstantF(base + 5, &vShininess.x, 1);

		break;
		// `點光源`
	case 1:
		g_pSelected_VS = g_pPointLight_VS;

		vAmbient = g_vMaterialAmbient * g_Lights[1].m_vAmbientColor;
		vDiffuse = g_vMaterialDiffuse * g_Lights[1].m_vDiffuseColor;
		vSpecular = g_vMaterialSpecular * g_Lights[1].m_vSpecularColor;

		device->SetVertexShaderConstantF(base + 1, &g_Lights[1].m_vPosition.x, 1);
		device->SetVertexShaderConstantF(base + 2, &g_Lights[1].m_vAttenuation.x, 1);
		device->SetVertexShaderConstantF(base + 3, &vAmbient.x, 1);
		device->SetVertexShaderConstantF(base + 4, &vDiffuse.x, 1);
		device->SetVertexShaderConstantF(base + 5, &vSpecular.x, 1);
		device->SetVertexShaderConstantF(base + 6, &vShininess.x, 1);

		break;
		// `聚光燈`
	case 2:
		g_pSelected_VS = g_pSpotLight_VS;

		vAmbient = g_vMaterialAmbient * g_Lights[2].m_vAmbientColor;
		vDiffuse = g_vMaterialDiffuse * g_Lights[2].m_vDiffuseColor;
		vSpecular = g_vMaterialSpecular * g_Lights[2].m_vSpecularColor;

		float spotlight_cutoff_cosine = FastMath::Cos( FastMath::DegreeToRadian(g_Lights[2].m_fSpotlightCutoff * 0.5f) );
		vSpotLightCoeff.Set(spotlight_cutoff_cosine, g_Lights[2].m_fSpotlightExponent, 0.0f, 0.0f);

		device->SetVertexShaderConstantF(base + 1, &g_Lights[2].m_vPosition.x, 1);
		device->SetVertexShaderConstantF(base + 2, &g_Lights[2].m_vDirection.x, 1);
		device->SetVertexShaderConstantF(base + 3, &g_Lights[2].m_vAttenuation.x, 1);
		device->SetVertexShaderConstantF(base + 4, &vSpotLightCoeff.x, 1);
		device->SetVertexShaderConstantF(base + 5, &vAmbient.x, 1);
		device->SetVertexShaderConstantF(base + 6, &vDiffuse.x, 1);
		device->SetVertexShaderConstantF(base + 7, &vSpecular.x, 1);
		device->SetVertexShaderConstantF(base + 8, &vShininess.x, 1);

		break;
	}
}
Esempio n. 24
0
 /* =============== */
 virtual void leave ()
 {
     m_devcs->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
 }
Esempio n. 25
0
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void MainLoop()
{
	for(;;)
	{ 
		MSG msg;
		if (PeekMessage (&msg,NULL,0,0,PM_NOREMOVE)) 
		{
			if( msg.message == WM_QUIT )
			{
				return ;
			}
			GetMessage (&msg,NULL,0,0);
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		else
		{
			// サーバーの更新を行う。
			g_server->Update();

			if( g_timer % 120 == 0 )
			{
				// エフェクトの停止
				g_manager->StopEffect( g_handle );

				// エフェクトの再生
				g_handle = g_manager->Play( g_effect, 0, 0, 0 );
			}

			// エフェクトの移動処理を行う。
			g_manager->AddLocation( g_handle, ::Effekseer::Vector3D( 0.2f, 0.0f, 0.0f ) );

			// エフェクトの更新処理を行う。
			g_manager->Update();
			
			
			g_d3d_device->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
			g_d3d_device->BeginScene();

			// エフェクトの描画開始処理を行う。
			g_renderer->BeginRendering();

			// エフェクトの描画を行う。
			g_manager->Draw();

			// エフェクトの描画終了処理を行う。
			g_renderer->EndRendering();

			g_d3d_device->EndScene();

			g_timer++;

			{
				HRESULT hr;
				hr = g_d3d_device->Present( NULL, NULL, NULL, NULL );

				// デバイスロスト処理
				switch ( hr )
				{
					// デバイスロスト
					case D3DERR_DEVICELOST:
					while ( FAILED( hr = g_d3d_device->TestCooperativeLevel() ) )
					{
						switch ( hr )
						{
							// デバイスロスト
							case D3DERR_DEVICELOST:
								::SleepEx( 1000, true );
								break;

							// デバイスロスト:リセット可
							case D3DERR_DEVICENOTRESET:
								
								// デバイスロストの処理を行う前に実行する
								g_renderer->OnLostDevice();

								D3DPRESENT_PARAMETERS d3dp;
								ZeroMemory(&d3dp, sizeof(d3dp));
								d3dp.BackBufferWidth = g_window_width;
								d3dp.BackBufferHeight = g_window_height;
								d3dp.BackBufferFormat = D3DFMT_X8R8G8B8;
								d3dp.BackBufferCount = 1;      
								d3dp.SwapEffect = D3DSWAPEFFECT_DISCARD;
								d3dp.Windowed = TRUE;
								d3dp.hDeviceWindow = g_window_handle;
								d3dp.EnableAutoDepthStencil = TRUE;
								d3dp.AutoDepthStencilFormat = D3DFMT_D16;

								g_d3d_device->Reset( &d3dp );

								// デバイスロストの処理の後に実行する
								g_renderer->OnResetDevice();

								break;
						}
					}
					break;
				}
			}
		}
	}
}
Esempio n. 26
0
 /* =============== */
 virtual void leave ()
 {
     for (uint_t idx = m_enter; idx < m_leave; idx += 2)
         m_devcs->SetRenderState((D3DRENDERSTATETYPE)m_value[idx], m_value[idx + 1]);
 }
bool DirectXTextureManager::loadTileSetFromTexture(	Game *game, 
													wstring dir,
													wstring sourceImageFileName,
													int tileWidth,
													int tileHeight)
{
	// CONVERT THE FILE NAME INTO A WINDOW LONG CHAR wchar_t (LPCWSTR)
	wstring sourcePath = dir + sourceImageFileName;

	LPDIRECT3DTEXTURE9 textureToDivide;
	LPDIRECT3DSURFACE9 surfaceToDivide;

	unsigned int result = fillTexture(sourcePath, &textureToDivide);
	textureToDivide->GetSurfaceLevel(0, &surfaceToDivide);
	if (result != S_OK) return false;

	// DETERMINE THE NUMBER OF TILE ROWS AND COLUMNS
	D3DSURFACE_DESC surfaceDesc;
	surfaceToDivide->GetDesc(&surfaceDesc);
	int textureWidth = surfaceDesc.Width;
	int textureHeight = surfaceDesc.Height;
	int columns = textureWidth/tileWidth;
	int rows = textureHeight/tileHeight;
	DirectXGraphics *dxg = (DirectXGraphics*)graphics;

	LPDIRECT3DDEVICE9 graphicsDevice = ((DirectXGraphics*)graphics)->getGraphicsDevice();

	// THE TILE SET IMAGE LOADED SUCCESSFULLY, SO LET'S CUT IT UP
	for (int row = 0; row < rows; row++)
	{
		for (int column = 0; column < columns; column++)
		{
			LPDIRECT3DTEXTURE9 extractedTexture;
			LPDIRECT3DSURFACE9 extractedSurface;
			result = graphicsDevice->CreateRenderTarget(tileWidth,
					tileHeight,
					D3DFMT_A8R8G8B8,
					D3DMULTISAMPLE_NONE, 0, false, &extractedSurface, NULL);
			if (result != S_OK) return false;
	
			RECT sourceRect;
			sourceRect.left = column * tileWidth;
			sourceRect.right = tileWidth + (column * tileWidth) - 1;
			sourceRect.top = row * tileHeight;
			sourceRect.bottom = tileHeight + (row * tileHeight) - 1;
			
			graphicsDevice->StretchRect(surfaceToDivide, &sourceRect, extractedSurface, NULL, D3DTEXF_NONE);

			// BUILD A UNIQUE FILE NAME FOR THIS TEXTURE
			wstring textureFilename = sourceImageFileName;

			unsigned int id = wstringTable.getNumWStringsInTable();
			wchar_t dot = '.';
			int dotIndex = textureFilename.rfind(dot);
			textureFilename = textureFilename.substr(0, dotIndex);
			wstringstream idWss;
			idWss << id;
			wstring idText;
			idWss >> idText;
			textureFilename = textureFilename + idText + L".png";
			textureFilename = wstring(dir.begin(), dir.end()) + textureFilename;
				
			// LET'S PUT THE SURFACE IN AN IMAGE FILE
			D3DXSaveSurfaceToFileW(textureFilename.c_str(), D3DXIFF_PNG, extractedSurface, NULL, NULL); 
			D3DXIMAGE_INFO info;
			HRESULT result = D3DXGetImageInfoFromFile(textureFilename.c_str(), &info);
			if (result != S_OK) return false;

			// AND THEN LOAD IT BACK IN AS A TEXTURE
			result = D3DXCreateTextureFromFileEx(	graphicsDevice,		// GPU
													textureFilename.c_str(),			// BITMAP FILE PATH/NAME
													tileWidth,			// BITMAP IMAGE WIDTH
													tileHeight,		// BITMAP IMAGE HEIGHT
													1,					// MIP-MAP LEVELS (1 FOR NO CHAIN)
													D3DPOOL_DEFAULT,	// THE TYPE OF SURFACE (STANDARD)
													D3DFMT_UNKNOWN,		// SURFACE FORMAT (DEFAULT)
													D3DPOOL_DEFAULT,	// MEMORY CLASS FOR THE TEXTURE
													D3DX_DEFAULT,		// IMAGE FILTER
													D3DX_DEFAULT,		// MIP FILTER
													NULL,			// COLOR KEY
													&info,				// BITMAP FILE INFO
													NULL,				// COLOR PALETTE
													&extractedTexture );	// THE TEXTURE WE ARE CREATING AND LOADING					
			if (result != S_OK) return false;

			// ADD IT TO THE STRING TABLE
			wstringTable.putWStringInTable(textureFilename);

			// AND ADD IT TO THE TEXTURES
			textures[textureFilename] = extractedTexture;

			//Delete File After Use
			int length;
			int slength = (int)textureFilename.length() + 1;
			length = WideCharToMultiByte(CP_ACP, 0, textureFilename.c_str(), slength, 0, 0, 0, 0);
			char* buffer = new char[length];
			WideCharToMultiByte(CP_ACP, 0, textureFilename.c_str(), slength, buffer, length, 0, 0); 
			std::string file(buffer);
			delete[] buffer;
			if (remove(file.c_str()) != 0)
				throw exception ("Error deleting file\n");			
		}
	}
	return true;
}
Esempio n. 28
0
 /* =============== */
 virtual void leave ()
 {
     for (uint_t idx = m_enter; idx < m_leave; idx += 3)
         m_devcs->SetSamplerState(m_value[idx], (D3DSAMPLERSTATETYPE)m_value[idx + 1], m_value[idx + 2]);
 }
Esempio n. 29
0
// 使用Direct3D9來繪圖
void RenderFrameDX9(void)
{
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
	// `消除畫面`
	device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
	// `開始下繪圖指令`
	device->BeginScene(); 
	// `設定矩陣`
	Matrix4x4 view_matrix = g_Control.GetViewMatrix();
	Matrix4x4 object_matrix = g_Control.GetObjectMatrix();
	device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
	device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &object_matrix);
	// `設定資料格式`
	device->SetFVF(D3DFVF_XYZ|D3DFVF_TEX1); 
	// `套用貼圖`
	device->SetTexture(0, g_pTexture);

	device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
	device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);

	switch(g_iFilterMode)
	{
	case 1: // linear filtering
		// `貼圖被放大時, 取最接近4個點來內插.`
		device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		// `貼圖被縮小時, 取最接近4個點來平均.`
		device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		// `不使用Mipmap`
		device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
		break;
	case 2: // bilinear filtering
		// `貼圖被放大時, 取最接近4個點來內插.`
		device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		// `貼圖被縮小時, 取最接近4個點來平均.`
		device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		// `取最接近大小的圖層`
		device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
		break;
	case 3: // trilinear filtering
		// `貼圖被放大時, 取最接近4個點來內插.`
		device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		// `貼圖被縮小時, 取最接近4個點來平均.`
		device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		// `取最接近大小的兩個圖層, 然後再內插.`
		device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
		break;
	case 4: // anisotropic filtering
		// `會根據縮放的長寬比例來取用貼圖, 不固定是取哪幾個圖.`
		device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
		device->SetSamplerState(0, D3DSAMP_MAXANISOTROPY, 8);
		// `取最接近大小的兩個圖層, 然後再內插.`
		device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
		break;
	}
	// `畫出矩形`
	device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, g_Quad, sizeof(Vertex_VT));
	// `宣告所有的繪圖指令都下完了`
	device->EndScene(); 
	// `把背景backbuffer的畫面呈現出來`
	device->Present( NULL, NULL, NULL, NULL );
}
Esempio n. 30
0
void Graphics::begin() {
	device->BeginScene();
}