Пример #1
0
void Direct3DUpdate(HWND hwnd)
{
    //////////////////////////////////////////////////////////////////////////
    // Five steps of rendering: clear, beginScene, render, EndScene, present  
    //////////////////////////////////////////////////////////////////////////   
	gPD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);

	RECT formatRect;
	GetClientRect(hwnd, &formatRect);

	gPD3DDevice->BeginScene();

	gPD3DDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);

	gPD3DDevice->SetStreamSource(0, gPVertexBuffer, 0, sizeof(CUSTOM_VERTEX));
	gPD3DDevice->SetFVF(D3DFVF_CUSTOM_VERTEX);
	gPD3DDevice->SetIndices(gPIndexBuffer);
	gPD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 17, 0, 16);

	int charCount = swprintf_s(gStrFPS, 20, _T("FPS:%0.3f"), GetFPS());
	gPFont->DrawText(NULL, gStrFPS, charCount, &formatRect, DT_TOP | DT_RIGHT, D3DCOLOR_XRGB(255, 39, 136));


	gPD3DDevice->EndScene();
	gPD3DDevice->Present(nullptr, nullptr, nullptr, nullptr);
}
Пример #2
0
// Render the model using the given matrix list as a hierarchy (must be one matrix per node)
// and from the given camera
void CMesh::Render(	CMatrix4x4* matrices, CCamera* camera )
{
	if (m_HasGeometry)
	{
		for (TUInt32 subMesh = 0; subMesh < m_NumSubMeshes; ++subMesh)
		{
			// Get a reference to the submesh and its material to reduce code clutter
			SSubMeshDX& sub = m_SubMeshesDX[subMesh];
			SMeshMaterialDX& material = m_Materials[sub.material];

			// Set textures from the material
			for (TUInt32 texture = 0; texture < material.numTextures; ++texture)
			{
				g_pd3dDevice->SetTexture( texture, material.textures[texture] );
			}
			
			// Set material properties
			SetMaterialColour( material.diffuseColour, material.specularColour, material.specularPower );

			// Use the render method from the sub-mesh's material and the matrix from its node
			UseMethod( material.renderMethod, &matrices[sub.node], camera );

			// Tell DirectX the vertex and index buffers to use
			g_pd3dDevice->SetStreamSource( 0, sub.vertexBuffer, 0, sub.vertexSize );
			g_pd3dDevice->SetIndices( sub.indexBuffer );

			// Draw the primitives from the buffer - a triangle list
			g_pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, sub.numVertices, 0,
			                                    sub.numIndices / 3 );
		}
	}
}
Пример #3
0
//-------------------------------------------------------------
// Trigger the render of indexed primitives
//-------------------------------------------------------------
void VCND3D9Shader::RenderIndexedPrimitive( VCNUInt faceCount, VCNUInt vertexCount, VCNInt primitiveType /*= D3DPT_TRIANGLELIST*/  )
{
	HRESULT hr = S_FALSE;

	// Get a pointer to the D3D device
	LPDIRECT3DDEVICE9 device = GetD3DDevice();

	// Start the technique and commit all the data
	VCNUInt numPasses;
	hr = mShader->Begin( &numPasses, 0 );
	VCN_ASSERT( SUCCEEDED(hr) );

	// Render all the passes of this technique (generally only 1).
	for( VCNUInt i=0; i<numPasses; ++i )
	{
		// Start the pass
		hr = mShader->BeginPass( i );
		VCN_ASSERT( SUCCEEDED(hr) );

		// Render indexed primitives
		hr = device->DrawIndexedPrimitive( (D3DPRIMITIVETYPE)primitiveType, 0, 0, vertexCount, 0, faceCount );
		VCN_ASSERT( hr != D3DERR_INVALIDCALL && "VCNDXShader::RenderIndexedPrimitive - D3DERR_INVALIDCALL!" );
		VCN_ASSERT( SUCCEEDED(hr) && "VCNDXShader::RenderIndexedPrimitive - DRAW FAILED!" );

		// End the pass
		hr = mShader->EndPass();
		VCN_ASSERT( SUCCEEDED(hr) );
	}

	hr = mShader->End();
	VCN_ASSERT( SUCCEEDED(hr) );
}
Пример #4
0
    void render_submodel( LPDIRECT3DDEVICE9 device, SubModel& submodel )
    {
        if( submodel.texture ) {
            device->SetTextureStageState(
                0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
            device->SetTextureStageState(
                0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
            device->SetTextureStageState(
                0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
            device->SetTextureStageState(
                0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
            device->SetTextureStageState(
                1, D3DTSS_COLOROP, D3DTOP_DISABLE );
            device->SetTextureStageState(
                1, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
            device->SetTexture( 0, submodel.texture->texture );
        } else {
            device->SetTextureStageState(
                0, D3DTSS_COLOROP, D3DTOP_DISABLE );
            device->SetTextureStageState(
                0, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
            device->SetTexture( 0, NULL );
        }

        device->SetIndices( submodel.ib );
        device->SetStreamSource(
            0, submodel.vb, 0, sizeof(model_vertex_type) );
        device->SetFVF( model_vertex_type::format );
        device->DrawIndexedPrimitive(
            D3DPT_TRIANGLELIST, 0, 0, submodel.index_source.size(), 0,
            submodel.index_source.size() / 3 );
    }
/**-----------------------------------------------------------------------------
 * 메시 그리기
 *------------------------------------------------------------------------------
 */
void DrawMesh( D3DXMATRIXA16* pMat )
{
    g_pd3dDevice->SetTransform( D3DTS_WORLD, pMat );
    g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(CUSTOMVERTEX) );
    g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
    g_pd3dDevice->SetIndices( g_pIB );
    g_pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, g_cxHeight*g_czHeight, 0, (g_cxHeight-1)*(g_czHeight-1)*2 );
}
/**-----------------------------------------------------------------------------
 * 메시 그리기
 *------------------------------------------------------------------------------
 */
void DrawMesh( D3DXMATRIXA16* pMat )
{
	g_pd3dDevice->SetRenderState( D3DRS_FILLMODE, g_bWireframe ? D3DFILL_WIREFRAME : D3DFILL_SOLID );
    g_pd3dDevice->SetTransform( D3DTS_WORLD, pMat );
    g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(CUSTOMVERTEX) );
    g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
    g_pd3dDevice->SetIndices( g_pIB );
	g_pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, g_cxHeight*g_czHeight, 0, g_nTriangles );
}
Пример #7
0
//*************************************************************************************************************
void DrawShadowVolume(const ShadowCaster& caster)
{
	extrude->SetMatrix("matWorld", &caster.world);
	extrude->CommitChanges();
	
	device->SetVertexDeclaration(shadowdecl);
	device->SetStreamSource(0, caster.vertices, 0, sizeof(D3DXVECTOR4));
	device->SetIndices(caster.indices);
	device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, caster.numvertices, 0, caster.numfaces);
}
Пример #8
0
void DrawCube()
{
	// translate model to origin
	D3DXMATRIX world ;
	D3DXMatrixTranslation(&world, 0.0f, 0.0f, 0.0f) ;
	g_pd3dDevice->SetTransform(D3DTS_WORLD, &world) ;

	// set view
	D3DXVECTOR3 eyePt(5.0f, 5.0f, -5.0f) ;
	D3DXVECTOR3 upVec(0.0f, 1.0f, 0.0f) ;
	D3DXVECTOR3 lookCenter(0.0f, 0.0f, 0.0f) ;

	D3DXMATRIX view ;
	D3DXMatrixLookAtLH(&view, &eyePt, &lookCenter, &upVec) ;
	g_pd3dDevice->SetTransform(D3DTS_VIEW, &view) ;

	// set projection
	D3DXMATRIX proj ;
	D3DXMatrixPerspectiveFovLH(&proj, D3DX_PI / 4, 1.0f, 1.0f, 1000.0f) ;
	g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &proj) ;

	D3DXMATRIX worldviewproj = world * view * proj;

	// Set matrix
	g_pEffect->SetMatrix(g_hWVP, &worldviewproj);

	// Set technique
	g_pEffect->SetTechnique(g_hTech);

	// Render pass
	UINT numPass = 0;
	g_pEffect->Begin(&numPass, 0);
	g_pEffect->BeginPass(0);


	// Set texture
	D3DXCreateTextureFromFile(g_pd3dDevice, "../Common/Media/crate.jpg", &g_pCubeTexture) ;
	g_pEffect->SetTexture("g_pCubeTexture", g_pCubeTexture);


	/*g_pd3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
	g_pd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
	g_pd3dDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);*/

	// Set stream source, and index buffer
	g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(Vertex) );
	g_pd3dDevice->SetIndices(g_pIB) ;
	g_pd3dDevice->SetFVF(VERTEX_FVF) ;

	// Totally 24 points and 12 triangles
	g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 24, 0, 12) ;

	g_pEffect->EndPass();
	g_pEffect->End();
}
Пример #9
0
HRESULT HookIDirect3DDevice9::DrawIndexedPrimitive(LPVOID _this,
												   D3DPRIMITIVETYPE PrimitiveType,
												   INT BaseVertexIndex,
												   UINT MinVertexIndex,
												   UINT NumVertices,
												   UINT startIndex,
												   UINT primCount)
{
	LOG_API();
	return pD3Dev->DrawIndexedPrimitive(PrimitiveType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
}
Пример #10
0
void cSubDivSurf::Draw( matrix4& mat )
{
	LPDIRECT3DDEVICE9 lpDevice = Graphics()->GetDevice();
	Graphics()->SetWorldMatrix( mat );

	HRESULT hr;

	// The index buffer
	LPDIRECT3DINDEXBUFFER9 pIndexBuffer = 0;

	// Create the index buffer
	lpDevice->CreateIndexBuffer(
		m_nTris * 3 * sizeof( WORD ),	// Size in bytes of buffer
		D3DUSAGE_WRITEONLY,				// Will only be writing to the buffer
		D3DFMT_INDEX16,					// 16 bit indices
		D3DPOOL_DEFAULT,				// Default memory pooling
		&pIndexBuffer,					// Address of the buffer pointer
		NULL );							// Reserved. set to NULL

	// Pointer to the index buffer data
	WORD* pData = 0;

	// Lock the index buffer
	pIndexBuffer->Lock( 0, 0, (void**)&pData, 0 );

	// Copy the index data into the index buffer
	CopyMemory( pData, m_d3dTriList, m_nTris * 3 * sizeof( WORD ) );

	// Unlock the index buffer
	pIndexBuffer->Unlock();

	// Tell Direct3D to use the index buffer
	lpDevice->SetIndices( pIndexBuffer );
	
	// Attach the vertex buffer to rendering stream 0
	lpDevice->SetStreamSource( 0, m_pVertexBuffer, 0, sizeof( sVertex ) );

	// Draw the primitive
	hr = lpDevice->DrawIndexedPrimitive(
		D3DPT_TRIANGLELIST,
		0,
		0,
		m_nVerts,
		0,
		m_nTris );

	if( FAILED( hr ) )
	{
		DP0("[cSubDivSurf::Draw]: DrawIndexedPrimitive failed!\n");
	}

	pIndexBuffer->Release();
}
Пример #11
0
//랜더
void Render(int timeDelta)
{
	//화면 청소
	if (SUCCEEDED(g_pDevice->Clear( 
		0,			//청소할 영역의 D3DRECT 배열 갯수		( 전체 클리어 0 )
		NULL,		//청소할 영역의 D3DRECT 배열 포인터		( 전체 클리어 NULL )
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL,	//청소될 버퍼 플레그 ( D3DCLEAR_TARGET 컬러버퍼, D3DCLEAR_ZBUFFER 깊이버퍼, D3DCLEAR_STENCIL 스텐실버퍼
		D3DCOLOR_XRGB(255, 255, 255),			//컬러버퍼를 청소하고 채워질 색상( 0xAARRGGBB )
		1.0f,				//깊이버퍼를 청소할값 ( 0 ~ 1 0 이 카메라에서 제일가까운 1 이 카메라에서 제일 먼 )
		0					//스텐실 버퍼를 채울값
		)))
	{
		//화면 청소가 성공적으로 이루어 졌다면... 랜더링 시작
		g_pDevice->BeginScene();

		Matrix44 mR;
		if (g_ani)
		{
			g_alpha += timeDelta / 1000.f;
			if (g_alpha > 1)
			{
				g_alpha = 1;
				g_ani = false;
			}
		}

		Vector3 v = g_from.Interpolate(g_to, g_alpha);
		Quaternion quat(Vector3(0,1,0), v);
		mR = quat.GetMatrix();

		Matrix44 tm = mR * g_LocalTm;
		g_pDevice->SetTransform(D3DTS_WORLD, (D3DXMATRIX*)&tm);

		g_pDevice->SetTexture(0, g_Texture);
		g_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		g_pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		g_pDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);


		g_pDevice->SetMaterial(&g_Mtrl);
		g_pDevice->SetStreamSource( 0, g_pVB, 0, sizeof(Vertex) );
		g_pDevice->SetIndices(g_pIB);
		g_pDevice->SetFVF( Vertex::FVF );
		g_pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, g_VtxSize, 0, g_FaceSize);


		//랜더링 끝
		g_pDevice->EndScene();
		//랜더링이 끝났으면 랜더링된 내용 화면으로 전송
		g_pDevice->Present( NULL, NULL, NULL, NULL );
	}
}
Пример #12
0
VOID render(){
	g_pDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(192,192,192), 1.0f, 0);
	if(SUCCEEDED(g_pDevice->BeginScene())){
		//Render to the back-buffer
		g_pDevice->SetStreamSource(0, g_pVB, 0, sizeof(CUSTOMVERTEX));
		g_pDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
		g_pDevice->SetIndices(g_pIB);
		g_pDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0,0,9,0,8);

		g_pDevice->EndScene();
	}
	g_pDevice->Present(NULL, NULL, NULL, NULL);
}
Пример #13
0
//-------------------------------------------------
// Name: Render
// Desc:
//-------------------------------------------------
HRESULT cprimitive::Render(LPDIRECT3DDEVICE9 pd3dDevice)
{
	HRESULT hr;

	W( pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE ) );

	W( pd3dDevice->SetIndices(g_pIB) );
	W( pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(CUSTOMVERTEX) ) );
	W( pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX ) );

	W( pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, m_numVertices, 0, m_numIndices/3) );

	return S_OK;
}
Пример #14
0
void ModelMesh::Render( LPDIRECT3DDEVICE9 device )
{
	if( !IsLoaded() )
		return;

	device->SetRenderState( D3DRS_FILLMODE, m_d3d_fillmode);
	device->SetRenderState( D3DRS_CULLMODE, m_d3d_cullmode );

 	device->SetStreamSource( 0, m_vb, 0, sizeof(ModelVertexStruct) );
	device->SetFVF( ModelVertexStruct::FVF );
	device->SetIndices( m_ib );

	device->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, m_vertex_size, 0, m_index_size / 3 );
}
//랜더
void Render(int timeDelta)
{
	//화면 청소
	if (SUCCEEDED(g_pDevice->Clear( 
		0,			//청소할 영역의 D3DRECT 배열 갯수		( 전체 클리어 0 )
		NULL,		//청소할 영역의 D3DRECT 배열 포인터		( 전체 클리어 NULL )
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL,	//청소될 버퍼 플레그 ( D3DCLEAR_TARGET 컬러버퍼, D3DCLEAR_ZBUFFER 깊이버퍼, D3DCLEAR_STENCIL 스텐실버퍼
		D3DCOLOR_XRGB(150, 150, 150),			//컬러버퍼를 청소하고 채워질 색상( 0xAARRGGBB )
		1.0f,				//깊이버퍼를 청소할값 ( 0 ~ 1 0 이 카메라에서 제일가까운 1 이 카메라에서 제일 먼 )
		0					//스텐실 버퍼를 채울값
		)))
	{
		//화면 청소가 성공적으로 이루어 졌다면... 랜더링 시작
		g_pDevice->BeginScene();

		g_pDevice->SetTransform(D3DTS_WORLD, (D3DXMATRIX*)&global->localTm);

		g_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		g_pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		g_pDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
		g_pDevice->SetSamplerState(0, D3DSAMP_ADDRESSU, global->addressMode) ;
		g_pDevice->SetSamplerState(0, D3DSAMP_ADDRESSV, global->addressMode) ;

		g_pDevice->SetMaterial(&global->mtrl);

		g_pDevice->SetTexture(0, global->texture);
		g_pDevice->SetStreamSource( 0, global->vb, 0, sizeof(Vertex) );
		g_pDevice->SetIndices(global->ib);
		g_pDevice->SetFVF( Vertex::FVF );
		g_pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, global->vtxSize, 0, global->faceSize);

		switch (global->mode)
		{
		case sGlobal::RENDER_FACE_NORMAL:
			g_pDevice->SetStreamSource( 0, global->fnvb, 0, sizeof(Vertex) );
			g_pDevice->DrawPrimitive( D3DPT_LINELIST, 0, global->faceNormalVtxSize/2);
			break;
		case sGlobal::RENDER_VERTEX_NORMAL:
			g_pDevice->SetStreamSource( 0, global->vnvb, 0, sizeof(Vertex) );
			g_pDevice->DrawPrimitive( D3DPT_LINELIST, 0, global->vertexNormalVtxSize/2);
			break;
		}

		//랜더링 끝
		g_pDevice->EndScene();
		//랜더링이 끝났으면 랜더링된 내용 화면으로 전송
		g_pDevice->Present( NULL, NULL, NULL, NULL );
	}
}
Пример #16
0
void VCND3D9Shader::RenderIndexedPrimitive(
	VCNPrimitiveType primitiveType, VCNInt baseVertexIndex, 
	VCNUInt minVertexIndex, VCNUInt numVertices, VCNUInt startIndex, VCNUInt primCount)
{
	HRESULT hr = S_FALSE;

	// Get a pointer to the D3D device
	LPDIRECT3DDEVICE9 device = GetD3DDevice();

	// Render primitives
	hr = device->DrawIndexedPrimitive( 
		(D3DPRIMITIVETYPE)primitiveType, baseVertexIndex, minVertexIndex, numVertices, startIndex, primCount);
	VCN_ASSERT( hr != D3DERR_INVALIDCALL && "VCNDXShader::RenderIndexedPrimitive - D3DERR_INVALIDCALL!" );
	VCN_ASSERT( SUCCEEDED(hr) && "VCNDXShader::RenderIndexedPrimitive - DRAW FAILED!" );
}
Пример #17
0
    void Draw( void ) override
    {
        HRESULT hr;
        LPDIRECT3DDEVICE9 device = DirectX9::Instance().Device;

        hr = device->SetMaterial(&m_Material->mat);
        m_Material->tex->Set();
        hr = device->DrawIndexedPrimitive(
            D3DPT_TRIANGLELIST,
            0,
            0,
            m_Data->m_MaxVertex,
            m_Material->start_index,
            m_MaxPrimitive);
    }
Пример #18
0
void CTile::Render(LPDIRECT3DDEVICE9 _device)
{
	_device->SetStreamSource( 0, m_pVB, 0, sizeof(TILEVERTEX) );
	_device->SetFVF( D3DFVF_CUSTOMVERTEX );
	_device->SetIndices( m_pIB );

	if(_b == true){
		_device->SetMaterial(&m_matrl);
	}else{
		ZeroMemory(&m_matrl, sizeof(D3DMATERIAL9));
		_device->SetMaterial(&m_matrl);
	}

	_device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 6, 0, 2);
	//_device->DrawPrimitive(D3DPT_TRIANGLELIST,0,2);
}
Пример #19
0
//랜더
void Render(int timeDelta)
{
	//화면 청소
	if (SUCCEEDED(g_pDevice->Clear( 
		0,			//청소할 영역의 D3DRECT 배열 갯수		( 전체 클리어 0 )
		NULL,		//청소할 영역의 D3DRECT 배열 포인터		( 전체 클리어 NULL )
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL,	//청소될 버퍼 플레그 ( D3DCLEAR_TARGET 컬러버퍼, D3DCLEAR_ZBUFFER 깊이버퍼, D3DCLEAR_STENCIL 스텐실버퍼
		D3DCOLOR_XRGB(255, 255, 255),			//컬러버퍼를 청소하고 채워질 색상( 0xAARRGGBB )
		1.0f,				//깊이버퍼를 청소할값 ( 0 ~ 1 0 이 카메라에서 제일가까운 1 이 카메라에서 제일 먼 )
		0					//스텐실 버퍼를 채울값
		)))
	{
		//화면 청소가 성공적으로 이루어 졌다면... 랜더링 시작
		g_pDevice->BeginScene();

		static float y = 0;
		y += timeDelta / 1000.f;
		// 각도가 2*PI 에 이르면 0으로 초기화한다.
		if (y >= 6.28f)
			y = 0;

		Matrix44 rx, ry, r;
		rx.SetRotationX(MATH_PI/4.f); 	// x축으로 45도 회전시킨다.
		ry.SetRotationY(y); // y축으로 회전
		r = rx*ry;
		g_pDevice->SetTransform(D3DTS_WORLD, (D3DXMATRIX*)&r);


		Matrix44 rry;
		rry.SetRotationY(-y); // y축으로 회전
		Vector3 dir = global->lightDir * rry;
		global->light.Direction = *(D3DXVECTOR3*)&dir;
		g_pDevice->SetLight(0, &global->light); // 광원 설정.


		g_pDevice->SetMaterial(&global->mtrl);
		g_pDevice->SetStreamSource( 0, global->vb, 0, sizeof(Vertex) );
		g_pDevice->SetIndices(global->ib);
		g_pDevice->SetFVF( Vertex::FVF );
		g_pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, global->vtxSize, 0, global->faceSize);

		//랜더링 끝
		g_pDevice->EndScene();
		//랜더링이 끝났으면 랜더링된 내용 화면으로 전송
		g_pDevice->Present( NULL, NULL, NULL, NULL );
	}
}
Пример #20
0
VOID Render()
{
    if ( !g_pd3dDevice ) return;
    LPDIRECT3DDEVICE9 d = g_pd3dDevice;

    d->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,0,255), 1.0f, 0 );
    
    if ( SUCCEEDED( d->BeginScene() ) ) {
        SetupMatrices();

        d->SetStreamSource( 0, g_pVertexBuff, 0, sizeof(CUSTOMVERTEX) );
        d->SetFVF( D3DFVF_CUSTOMVERTEX );
        d->SetIndices( g_pIndexBuff ); // 인덱스 버퍼 선택
        d->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12 );
        d->EndScene();
    }
    d->Present( NULL, NULL, NULL, NULL );
}
Пример #21
0
// Draw cube
void DrawCube()
{
	// Set texture
	D3DXCreateTextureFromFile(g_pd3dDevice, "../Common/Media/crate.jpg", &g_pCubeTexture) ;
	g_pd3dDevice->SetTexture(0, g_pCubeTexture) ;

	g_pd3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
	g_pd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
	g_pd3dDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

	// Set stream source, and index buffer
	g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(Vertex) );
	g_pd3dDevice->SetIndices(g_pIB) ;
	g_pd3dDevice->SetFVF(VERTEX_FVF) ;

	// Totally 24 points and 12 triangles
	g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 24, 0, 12) ;
}
Пример #22
0
//랜더
void Render(int timeDelta)
{
	//화면 청소
	if (SUCCEEDED(g_pDevice->Clear( 
		0,			//청소할 영역의 D3DRECT 배열 갯수		( 전체 클리어 0 )
		NULL,		//청소할 영역의 D3DRECT 배열 포인터		( 전체 클리어 NULL )
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL,	//청소될 버퍼 플레그 ( D3DCLEAR_TARGET 컬러버퍼, D3DCLEAR_ZBUFFER 깊이버퍼, D3DCLEAR_STENCIL 스텐실버퍼
		D3DCOLOR_XRGB(255, 255, 255),			//컬러버퍼를 청소하고 채워질 색상( 0xAARRGGBB )
		1.0f,				//깊이버퍼를 청소할값 ( 0 ~ 1 0 이 카메라에서 제일가까운 1 이 카메라에서 제일 먼 )
		0					//스텐실 버퍼를 채울값
		)))
	{
		//화면 청소가 성공적으로 이루어 졌다면... 랜더링 시작
		g_pDevice->BeginScene();

		static float y = 0;
		y += timeDelta / 1000.f;
		// 각도가 2*PI 에 이르면 0으로 초기화한다.
		if (y >= 6.28f)
			y = 0;

		//Matrix44 rx, ry, r;
		//rx.SetRotationX(MATH_PI/2.f); 	// x축으로 45도 회전시킨다.
		//ry.SetRotationY(y); // y축으로 회전
		//r = rx*ry;
		//g_pDevice->SetTransform(D3DTS_WORLD, (D3DXMATRIX*)&r);

		g_pDevice->SetTexture(0, g_Texture1);
		g_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		g_pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		g_pDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);

		g_pDevice->SetMaterial(&g_Mtrl);
		g_pDevice->SetStreamSource( 0, g_pVB, 0, sizeof(Vertex) );
		g_pDevice->SetIndices(g_pIB);
		g_pDevice->SetFVF( Vertex::FVF );
		g_pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, g_VtxSize, 0, g_FaceSize);

		//랜더링 끝
		g_pDevice->EndScene();
		//랜더링이 끝났으면 랜더링된 내용 화면으로 전송
		g_pDevice->Present( NULL, NULL, NULL, NULL );
	}
}
Пример #23
0
bool si3::SealData::draw(
	LPDIRECT3DDEVICE9 device,
	const D3DXMATRIX & world_mat,
	LPDIRECT3DTEXTURE9 texture,
	IDirect3DVertexBuffer9 * vertbuff,
	IDirect3DIndexBuffer9 * indexbuff,
	int index_num,
	int triangle_num,
	const D3DMATERIAL9 & material) const
{
	// 頂点フォーマット設定
	device->SetFVF(LAND_FVF);

	//マテリアル設定
	device->SetMaterial(&material);

	//テクスチャ設定
	device->SetTexture(0, texture);

	device->SetStreamSource(0, vertbuff, 0, sizeof(DxTop2D));
	device->SetIndices(indexbuff);

	// ライティング無し
	device->LightEnable(0, FALSE);
	device->SetRenderState(D3DRS_LIGHTING, FALSE);

	device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);

	// プリミティブ描画
	device->DrawIndexedPrimitive(
		D3DPT_TRIANGLESTRIP,
		0,
		0,
		index_num,
		0,
		triangle_num);

	// ライティング有り
	device->LightEnable(0, TRUE);
	device->SetRenderState(D3DRS_LIGHTING, TRUE);

	return true;
}
Пример #24
0
//----------------------------------------
//Name : DrawPrimitive()
//DESC : 绘制顶点缓存中的图形
//----------------------------------------
void DrawPrimitive()
{
	//设置渲染状态
	g_pd3dDevice->SetRenderState(D3DRS_LIGHTING,false);
	g_pd3dDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_CCW);



	//渲染三角形

	//需要通过IDirect3DDevice9接口的SetStreamSource方法将包含几何体信息的顶点缓存与渲染流水线相关联
	/*
	HRESULT IDirect3DDevice9::SetStreamSource(
	UINT  StreamNumber, //用于指定与该顶点缓存建立连接的数据流
	IDirect3DVertexBuffer9 *pStreamData, //包含顶点数据的顶点缓存指针
	UINT  OffsetInBytes, //在数据流中以字节为单位的偏移量
	UINT  Stride //在顶点缓冲中存储的每个顶点结构的大小,可以通过sizeof运算符计算顶点结构的实际大小
	);

	*/
	//渲染三角形
	g_pd3dDevice->SetStreamSource(0,g_pVertexBuf,0,sizeof(CUSTOMVERTEX));

	//调用IDirect3DDevice9接口的SetFVF方法指定顶点格式
	g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);

	//将物体模型的顶点填充到顶点缓存,并设置数据流输入源和顶点格式后,可以调用IDirect3DDevice9接口的DrawPrimitive方法根据顶点缓存中的顶点绘制模型。
	/*
	HRESULT IDirect3DDevice9::DrawPrimitive(
	D3DPRIMITIVETYPE  PrimitiveType,
	UINT  StartVertex,
	UINT  PrimitiveCount
	);

	*/
	//利用顶点缓存绘制矩形
	//g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST,0,2);


	//利用索引缓存绘制矩形
	g_pd3dDevice->SetIndices(g_pIndexBuf);
	g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,0,8,0,12);
}
Пример #25
0
void CGutModel_DX9::Render(int mask)
{
	LPDIRECT3DDEVICE9 pDevice = GutGetGraphicsDeviceDX9();
	
	bool bSubMtl = mask ? true : false;

	for ( int i=0; i<m_iNumMeshes; i++ )
	{
		sModelMesh_DX9 *pMesh = m_pMeshArray + i;
	
		for ( int j=0; j<pMesh->m_iNumVertexChunks; j++ )
		{
			sModelVertexChunk_DX9 *pVertexChunk = pMesh->m_pVertexChunk + j;
			pDevice->SetFVF(pVertexChunk->m_FVF);

			pDevice->SetStreamSource(0, pVertexChunk->m_pVertexBuffer, 0, pVertexChunk->m_iVertexSize);
			pDevice->SetIndices(pVertexChunk->m_pIndexBuffer);

			for (int l=0; l<pVertexChunk->m_iNumBatches; l++ )
			{
				sModelBatch *pBatch = pVertexChunk->m_pBatchArray + l;

				if ( bSubMtl )
				{
					if ( s_pMaterialOverwrite )
					{
						s_pMaterialOverwrite->Submit(mask);
					}
					else if ( m_pMaterialArray )
					{
						if ( pBatch->m_iMaterialID>=0 )
							m_pMaterialArray[pBatch->m_iMaterialID].Submit(mask);
						else
							m_pMaterialArray[0].Submit(mask);
					}
				}

				pDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, pVertexChunk->m_iNumVertices, pBatch->m_iIndexArrayBegin, pBatch->m_iNumPrimitives);
			}
		}
	}
}
Пример #26
0
VOID jcd3d::jcd3d_display(DWORD timeDelta)
{
	if(lpd3dd != NULL)
	{
		static FLOAT eyeRadius = 6.0f;
		static FLOAT eyeDegree = 0.0f;
		static FLOAT eyeHeight = 0.0f;
		if(jcd3d_keyDown('A'))
		{
			eyeDegree += 0.05f;
		}
		if(jcd3d_keyDown('D'))
		{
			eyeDegree -= 0.05f;
		}
		if(jcd3d_keyDown('W'))
		{
			eyeHeight += 0.05f;
		}
		if(jcd3d_keyDown('S'))
		{
			eyeHeight -= 0.05f;
		}
		D3DXMATRIX view;
		D3DXVECTOR3 eye(cosf(eyeDegree) * eyeRadius, eyeHeight, sinf(eyeDegree) * eyeRadius);
		D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
		D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
		D3DXMatrixLookAtLH(&view, &eye, &target, &up);
		lpd3dd->SetTransform(D3DTS_VIEW, &view);

		lpd3dd->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
		lpd3dd->BeginScene();

		lpd3dd->SetStreamSource(0, lpvb, 0, sizeof(JCD3D_Vertex_xyz_diffuse));
		lpd3dd->SetFVF(JCD3D_Vertex_xyz_diffuse::FVF);
		lpd3dd->SetIndices(lpib);
		lpd3dd->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, CORNOR_AMOUNT * (LAYER_AMOUNT + 1), 0, CORNOR_AMOUNT * 2 * LAYER_AMOUNT);

		lpd3dd->EndScene();
		lpd3dd->Present(NULL, NULL, NULL, NULL);
	}
}
Пример #27
0
void dbTerrain::Render()
{
	if (dbDevice::canRender() != D3D_OK)
		return;

	LPDIRECT3DDEVICE9 dev = dbDevice::getDevice();
	HRESULT hr;

	hr = dev->SetStreamSource(0, vertex_buffer_.GetVB(), 0, sizeof(TERRAIN_VERTEX));
	hr = dev->SetIndices(index_buffer_.GetIB());
	hr = dev->SetFVF(TERRAIN_VERTEX::FVF);
	
	dbDevice::SetRenderState( D3DRS_CULLMODE, D3DCULL_CW);
//	dbDevice::SetRenderState( D3DRS_LIGHTING, false );
	
	if (FAILED( dev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, max_vertex_, 0, max_index_ / 3)))
		DBX_ERROR("Could not render terrain!");

//	dbDevice::SetRenderState( D3DRS_LIGHTING, true );
}
Пример #28
0
		HRESULT Grid::VRender(Scene * pScene)
		{
			// This is slightly different from the Chapter 7 implementation...

			LPDIRECT3DDEVICE9 pDevice = pScene->m_pDevice;

			DWORD oldLightMode;
			pDevice->GetRenderState( D3DRS_LIGHTING, &oldLightMode );
			pDevice->SetRenderState( D3DRS_LIGHTING, FALSE );

			DWORD oldCullMode;
			pDevice->GetRenderState( D3DRS_CULLMODE, &oldCullMode );
			pDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

			// Setup our texture. Using textures introduces the texture stage states,
			// which govern how textures get blended together (in the case of multiple
			// textures) and lighting information. In this case, we are modulating
			// (blending) our texture with the diffuse color of the vertices.

			pDevice->SetTexture( 0, m_pTexture );
			pDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
			pDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
			pDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );

			pDevice->SetStreamSource( 0, m_pVerts, 0, sizeof(COLORED_TEXTURED_VERTEX) );
			pDevice->SetIndices(m_pIndices);
			pDevice->SetFVF( D3DFVF_COLORED_TEXTURED_VERTEX );
			pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST , 0, 0, m_numVerts, 0, m_numPolys );

			// Notice that the render states are returned to 
			// their original settings.....
			// Could there be a better way???

			pDevice->SetTexture (0, NULL);
			pDevice->SetRenderState( D3DRS_LIGHTING, oldLightMode );
			pDevice->SetRenderState( D3DRS_CULLMODE, oldCullMode );

			return S_OK;
		}
bool CNO::Draw( LPDIRECT3DDEVICE9 dev)
{
	CBranch::sIBNode *node;

	// set custom vertex
	dev->SetFVF( CUSTOM_BODY_VERTEX_FVF);
	// set vertex buffer
	dev->SetStreamSource( 0, m_bodyVertBuf, 0, sizeof( BODY_VERTEX));
	// set index buffer
	dev->SetIndices( m_indexBuffer);			

	// go through all active levels and their drawing chain and draw.
	for( int i= 0; i < this->GetNumOfActiveLvls( ); i++)
	{
		CBranch *curr = this->GetLevelHeads( i)->GetChainPointers( )->NextInBodyDraw;
		while( curr)
		{	
			// set model matrix
			dev->SetTransform( D3DTS_WORLD, &curr->GetWorldMatrix( ) );

			// draw the branch
			node = curr->GetBodyNode( );

			if( D3D_OK != dev->DrawIndexedPrimitive( D3DPT_TRIANGLELIST
				, node->pToVert
				, 0
				, node->count
				, node->pToIndx
				, ( node->count - NUM_OF_VERT_ON) * 2
				) )
				return false;	

			// step to next
			curr = curr->GetChainPointers( )->NextInBodyDraw;
		}
	}

	return true;
}
Пример #30
0
//描画
void Vertices::Draw(LPDIRECT3DDEVICE9 pD3DDevice, D3DXMATRIX *pmtrx) 
{
	if (!pD3DDevice || !pVertexBuffer)
		return;

	D3DXMATRIX mtrxOld; //ワールド変換行列保存用
	pD3DDevice->GetTransform(D3DTS_WORLD, &mtrxOld); //ワールド行列を保存
	pD3DDevice->SetTransform(D3DTS_WORLD, pmtrx); //デバイスにマトリックスを設定

	pD3DDevice->SetStreamSource(0, pVertexBuffer, 0, sizeof(D3DVERTEX)); //頂点バッファをデバイスのストリームにセット
	if (pIndexBuffer) //インデックスバッファが存在する場合
	{
		pD3DDevice->SetIndices(pIndexBuffer); //インデックスバッファをセット
		pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, vectorD3DVERTEX.size(), 0, Primitives); //頂点インデックスありで描画
	} else { //存在しない場合
		pD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, Primitives); //頂点インデックスなしで描画
	}

	pD3DDevice->SetTransform(D3DTS_WORLD, &mtrxOld); //デバイスのワールド変換行列を復元

	return;
}