示例#1
0
void DrawLightmapPage( int lightmapPageID )
{
	// assumes that we are already in ortho mode.
	int lightmapPageWidth, lightmapPageHeight;

	IMesh* pMesh = materialSystemInterface->GetDynamicMesh( true, NULL, NULL, g_materialDebugLightmap );
//	materialSystemInterface->Bind( g_materialWireframe );
//	IMesh* pMesh = materialSystemInterface->GetDynamicMesh( g_materialWireframe );

	materialSystemInterface->GetLightmapPageSize( lightmapPageID, &lightmapPageWidth, &lightmapPageHeight );
	materialSystemInterface->BindLightmapPage( lightmapPageID );

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

	// texcoord 1 is lightmaptexcoord for fixed function.
	meshBuilder.TexCoord2f( 1, 0.0f, 0.0f );
	meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.TexCoord2f( 1, 1.0f, 0.0f );
	meshBuilder.Position3f( lightmapPageWidth, 0.0f, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.TexCoord2f( 1, 1.0f, 1.0f );
	meshBuilder.Position3f( lightmapPageWidth, lightmapPageHeight, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.TexCoord2f( 1, 0.0f, 1.0f );
	meshBuilder.Position3f( 0.0f, lightmapPageHeight, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.End();
	pMesh->Draw();
}
void CHoloShipComm::Draw( IMatRenderContext *pRenderContext )
{
	m_vecPanelWorldOffset.x = -m_flWidth * m_flScale;

	BaseClass::Draw( pRenderContext );

	GetColorVar()->SetVecValue( HOLO_COLOR_HIGHLIGHT );
	SetHoloAlpha( 1.0f );

	const float flTriangleStart = -0.5f;
	const float flTriangleHeight = 0.03f;
	IMesh *pMesh = pRenderContext->GetDynamicMesh( true, 0, 0, GetMaterial() );
	CreateSlantedRect( pMesh, 0, flTriangleStart, m_flWidth * -m_flScale, flTriangleHeight );

	//CMeshBuilder builder;
	//builder.Begin( pMesh, MATERIAL_TRIANGLES, 1 );

	//builder.Position3f( 0, 0, flTriangleStart );
	//builder.AdvanceVertex();

	//builder.Position3f( 0, 0, flTriangleStart + flTriangleHeight );
	//builder.AdvanceVertex();

	//builder.Position3f( 0, -m_flWidth * m_flScale, flTriangleStart );
	//builder.AdvanceVertex();

	//builder.End();
	pMesh->Draw();

	if ( m_flWaveVisibilityAmount > 0.0f )
	{
		DrawWaveForm( pRenderContext );
	}
}
void CReplayRenderer::DrawResolvingQuad( int nWidth, int nHeight )
{
	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	IMesh *pMesh = pRenderContext->GetDynamicMesh();
	CMeshBuilder meshBuilder;

	// Epsilons for 1:1 texel to pixel mapping
	float fWidthEpsilon = IsOSX() ? 0.0f : 0.5f / ((float) nWidth);
	float fHeightEpsilon = IsOSX() ? 0.0f : 0.5f / ((float) nHeight);

	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

	meshBuilder.Position3f( -1.0f, 1.0f, 0.5f );	// Upper left
	meshBuilder.TexCoord2f( 0, 0.0f + fWidthEpsilon, 0.0f + fHeightEpsilon );
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f( -1.0f,  -1.0f, 0.5f );	// Lower left
	meshBuilder.TexCoord2f( 0, 0.0f + fWidthEpsilon, 1.0f + fHeightEpsilon );
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f( 1.0f, -1.0f, 0.5f );	// Lower right
	meshBuilder.TexCoord2f( 0, 1.0f + fWidthEpsilon, 1.0f + fHeightEpsilon );
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f( 1.0f, 1.0f, 0.5f );		// Upper right
	meshBuilder.TexCoord2f( 0, 1.0f + fWidthEpsilon, 0.0f + fHeightEpsilon );
	meshBuilder.AdvanceVertex();

	meshBuilder.End();
	pMesh->Draw();
}
示例#4
0
float CGWIC_Cell::GetTerrainHeightUnderPointMetric(irr::core::vector3df pnt)
{
	u32 x = floor(pnt.X);
	u32 z = floor(pnt.Z);
	if (x > 255) x = 255;
	if (z > 255) z = 255;
	u32 index = x * 256 + z;
	IMesh* pMesh = terrain->getMesh();
	float res = 0.f;
//	float max = 0;
	const float scy = terrain->getScale().Y;
	//FIXME: get the true position in meters
	for (u32 n=0; n<pMesh->getMeshBufferCount(); n++) {
		IMeshBuffer* pMeshBuffer = pMesh->getMeshBuffer(n);
		if (pMeshBuffer->getVertexType() != EVT_2TCOORDS) continue;
		S3DVertex2TCoords* pVertices = (S3DVertex2TCoords*)pMeshBuffer->getVertices();
		res = pVertices[index].Pos.Y / scy;
//		res = (pVertices[index].Pos.Y + terrain->getPosition().Y) / scy;
//		res += terrain->getPosition().Y / GWIC_IRRUNITS_PER_METER;
//		std::cerr << "POSIT  " << res << std::endl;
//		for (u32 k=0; k<(256*256); k++) if (pVertices[k].Pos.Y > max) max = pVertices[k].Pos.Y;
//		std::cerr << "MAXX  " << max << std::endl;
		break;
	}
	return res;
}
//-----------------------------------------------------------------------------
// paint it!
//-----------------------------------------------------------------------------
void CMaterialViewPanel::Paint()
{
	// Draw a background (translucent objects will appear that way)

	// FIXME: Draw the outline of this panel?
	if (!m_pMaterial)
		return;

	g_pMatSystemSurface->Begin3DPaint( 0, 0, m_iViewableWidth, m_iViewableHeight );
	g_pMaterialSystem->MatrixMode( MATERIAL_PROJECTION );
	g_pMaterialSystem->LoadIdentity();
	g_pMaterialSystem->Scale( 1, -1, 1 );
	g_pMaterialSystem->Ortho( 0, 0, m_iViewableWidth, m_iViewableHeight, 0, 1 );

	g_pMaterialSystem->Bind( m_pMaterial );
	IMesh *pMesh = g_pMaterialSystem->GetDynamicMesh();
	CMeshBuilder meshBuilder;

	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

	if (!m_bUseActualSize)
	{
		DrawStretchedToPanel( meshBuilder );
	}
	else
	{
		DrawActualSize( meshBuilder );
	}

	meshBuilder.End();
	pMesh->Draw();

	g_pMatSystemSurface->End3DPaint( );
}
示例#6
0
void OverlayCameraRenderTarget( const char *pszMaterialName, float flX, float flY, float w, float h )
{
	float offsetS = ( 0.5f / 256.0f );
	float offsetT = ( 0.5f / 256.0f );
	IMaterial *pMaterial;
	pMaterial = materials->FindMaterial( pszMaterialName, TEXTURE_GROUP_OTHER, true );
	if( !IsErrorMaterial( pMaterial ) )
	{
		CMatRenderContextPtr pRenderContext( materials );
		pRenderContext->Bind( pMaterial );
		IMesh* pMesh = pRenderContext->GetDynamicMesh( true );

		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

		meshBuilder.Position3f( flX, flY, 0.0f );
		meshBuilder.TexCoord2f( 0, 0.0f + offsetS, 0.0f + offsetT );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f( flX+w, flY, 0.0f );
		meshBuilder.TexCoord2f( 0, 1.0f + offsetS, 0.0f + offsetT );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f( flX+w, flY+h, 0.0f );
		meshBuilder.TexCoord2f( 0, 1.0f + offsetS, 1.0f + offsetT );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f( flX, flY+h, 0.0f );
		meshBuilder.TexCoord2f( 0, 0.0f + offsetS, 1.0f + offsetT );
		meshBuilder.AdvanceVertex();

		meshBuilder.End();
		pMesh->Draw();
	}
}
示例#7
0
void CGWIC_Cell::RandomizeTerrain(float subdelta)
{
	IMesh* pMesh = terrain->getMesh();
	s32 Q = static_cast<s32> (subdelta);
	for (u32 n=0; n<pMesh->getMeshBufferCount(); n++) {
		IMeshBuffer* pMeshBuffer = pMesh->getMeshBuffer(n);
		if (pMeshBuffer->getVertexType() != EVT_2TCOORDS) continue;
		S3DVertex2TCoords* pVertices = (S3DVertex2TCoords*)pMeshBuffer->getVertices();
		//1. find the current max & min, since we don't want to escalate landscape
		float max = 0;
		float min = 256;
		u32 i;
		for (i=0; i<(256*256); i++) {
			if (pVertices[i].Pos.Y < min) min = pVertices[i].Pos.Y;
			if (pVertices[i].Pos.Y > max) max = pVertices[i].Pos.Y;
		}
		std::cout << "RandTerr: min=" << min << ";  max=" << max << std::endl;
		//2. create temp array & randomize it
		std::vector<float> tmparr;
		float cy;
		for (i=0; i<(256*256); i++) {
			if (Q) {
				cy = Random_FLOAT(max-min);
				cy += min;
			} else cy = 0;
			tmparr.push_back(cy);
		}
		std::cout << std::endl;
		//3. interpolate vertices inside big quads
		s32 A = 0;
		if (Q) A = 256 / Q + 1;
		for (int qx=0; qx<A; qx++)
			for (int qy=0; qy<A; qy++) {
				//TODO: remove unnecessary vars
				int x0 = qx * Q;
				int y0 = qy * Q;
				int xe = x0 + Q;
				if (xe > 255) xe = 255;
				int ye = y0 + Q;
				if (ye > 255) ye = 255;
				float hx0 = tmparr[x0*256+y0];
				float hy0 = (qx%2)? tmparr[xe*256+ye]:hx0;
				float hxe = tmparr[xe*256+y0];
				float hye = tmparr[x0*256+ye];
				float lhy = hye - hy0;
				float lhx = hxe - hx0;
				for (int cx=x0; cx<xe; cx++)
					for (int cy=y0; cy<ye; cy++) {
						float ch = (((qx%2)?(x0-cx):(cx-x0))/lhx)*lhx+hx0;
						ch += (((qy%2)?(y0-cy):(cy-y0))/lhy)*lhy+hy0;
						tmparr[cx*256+cy] = ch / 2;
					}
			}
		//4. get result back
		for (i=0; i<(256*256); i++)
			pVertices[i].Pos.Y = tmparr[i];
		break;
	}
	TerrainChanged();
}
//-----------------------------------------------------------------------------
// Purpose: Renders a selection gizmo at our bounds center.
// Input  : pRender - Rendering interface.
//-----------------------------------------------------------------------------
void Marker3D::RenderTool3D(CRender3D *pRender)
{
	if (!IsActiveTool())
	{
		return;
	}

	Vector *pPos;

	if (IsTranslating())
	{
		pPos = &m_vecTranslatePos;
	}
	else
	{
		if (IsEmpty())
		{
			return;
		}

		pPos = &m_vecPos;
	}
	
	//
	// Setup the renderer.
	//
	pRender->SetRenderMode(RENDER_MODE_WIREFRAME);

	CMeshBuilder meshBuilder;
	IMesh* pMesh = MaterialSystemInterface()->GetDynamicMesh();

	meshBuilder.Begin(pMesh, MATERIAL_LINES, 3);

	meshBuilder.Position3f(g_MIN_MAP_COORD, (*pPos)[1], (*pPos)[2]);
	meshBuilder.Color3ub(255, 0, 0);
	meshBuilder.AdvanceVertex();
	meshBuilder.Position3f(g_MAX_MAP_COORD, (*pPos)[1], (*pPos)[2]);
	meshBuilder.Color3ub(255, 0, 0);
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f((*pPos)[0], g_MIN_MAP_COORD, (*pPos)[2]);
	meshBuilder.Color3ub(0, 255, 0);
	meshBuilder.AdvanceVertex();
	meshBuilder.Position3f((*pPos)[0], g_MAX_MAP_COORD, (*pPos)[2]);
	meshBuilder.Color3ub(0, 255, 0);
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f((*pPos)[0], (*pPos)[1], g_MIN_MAP_COORD);
	meshBuilder.Color3ub(0, 0, 255);
	meshBuilder.AdvanceVertex();
	meshBuilder.Position3f((*pPos)[0], (*pPos)[1], g_MAX_MAP_COORD);
	meshBuilder.Color3ub(0, 0, 255);
	meshBuilder.AdvanceVertex();

	meshBuilder.End();
	pMesh->Draw();

	pRender->SetRenderMode(RENDER_MODE_DEFAULT);
}
示例#9
0
void Object2d::setVisible(bool vis) {
   list<IMesh *>::iterator mesh;
   for (mesh = m_meshList.begin(); mesh != m_meshList.end(); ++mesh) {
      IMesh* temp = *mesh;
      
      temp->setVisible(vis);
   }
}
示例#10
0
static void DispInfo_DrawChainNormals( IDispInfo *pHead )
{
#ifndef SWDS
#ifdef _DEBUG
    // Only do it in debug because we're only storing the info then
    Vector p;

    materialSystemInterface->Bind( g_pMaterialWireframeVertexColor );

    for( IDispInfo *pCur=pHead; pCur; pCur = pCur->GetNextInRenderChain() )
    {
        CDispInfo *pDisp = static_cast<CDispInfo*>( pCur );

        int nVerts = pDisp->NumVerts();

        IMesh *pMesh = materialSystemInterface->GetDynamicMesh( );
        CMeshBuilder meshBuilder;
        meshBuilder.Begin( pMesh, MATERIAL_LINES, nVerts * 3 );

        for( int iVert=0; iVert < nVerts; iVert++ )
        {
            CDispRenderVert* pVert = pDisp->GetVertex(iVert);
            meshBuilder.Position3fv( pVert->m_vPos.Base() );
            meshBuilder.Color3ub( 255, 0, 0 );
            meshBuilder.AdvanceVertex();

            VectorMA( pVert->m_vPos, 5.0f, pVert->m_vNormal, p );
            meshBuilder.Position3fv( p.Base() );
            meshBuilder.Color3ub( 255, 0, 0 );
            meshBuilder.AdvanceVertex();

            meshBuilder.Position3fv( pVert->m_vPos.Base() );
            meshBuilder.Color3ub( 0, 255, 0 );
            meshBuilder.AdvanceVertex();

            VectorMA( pVert->m_vPos, 5.0f, pVert->m_vSVector, p );
            meshBuilder.Position3fv( p.Base() );
            meshBuilder.Color3ub( 0, 255, 0 );
            meshBuilder.AdvanceVertex();

            meshBuilder.Position3fv( pVert->m_vPos.Base() );
            meshBuilder.Color3ub( 0, 0, 255 );
            meshBuilder.AdvanceVertex();

            VectorMA( pVert->m_vPos, 5.0f, pVert->m_vTVector, p );
            meshBuilder.Position3fv( p.Base() );
            meshBuilder.Color3ub( 0, 0, 255 );
            meshBuilder.AdvanceVertex();
        }

        meshBuilder.End();
        pMesh->Draw();
    }
#endif
#endif
}
void DrawSmokeFogOverlay()
{
	if(g_SmokeFogOverlayAlpha == 0 || !g_pSmokeFogMaterial || !materials)
		return;

	// Hard-coded for now..
	g_SmokeFogOverlayColor.Init( 0.3, 0.3, 0.3 );
	
	CMatRenderContextPtr pRenderContext( materials );

	pRenderContext->MatrixMode( MATERIAL_PROJECTION );
	pRenderContext->LoadIdentity();
	pRenderContext->Ortho( 0, 0, 1, 1, -99999, 99999 );

	pRenderContext->MatrixMode( MATERIAL_VIEW );
	pRenderContext->LoadIdentity();

	pRenderContext->MatrixMode( MATERIAL_MODEL );
	pRenderContext->LoadIdentity();

	IMesh* pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, g_pSmokeFogMaterial );
	CMeshBuilder meshBuilder;

	static float dist = 10;

	Vector vColor = g_SmokeFogOverlayColor;
	vColor.x = MIN(MAX(vColor.x, 0), 1);
	vColor.y = MIN(MAX(vColor.y, 0), 1);
	vColor.z = MIN(MAX(vColor.z, 0), 1);
	float alpha = MIN(MAX(g_SmokeFogOverlayAlpha, 0), 1);

	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

	meshBuilder.Position3f( 0, 0, dist );
	meshBuilder.Color4f( vColor.x, vColor.y, vColor.z, alpha );
	meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f( 0, 1, dist );
	meshBuilder.Color4f( vColor.x, vColor.y, vColor.z, alpha );
	meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f( 1, 1, dist );
	meshBuilder.Color4f( vColor.x, vColor.y, vColor.z, alpha );
	meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.Position3f( 1, 0, dist );
	meshBuilder.Color4f( vColor.x, vColor.y, vColor.z, alpha );
	meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.End();
	pMesh->Draw();
}
示例#12
0
IMesh *World::AddMesh(const c8 *meshName)
{
	IMesh *mesh = new Mesh(
			engine->GetIrrlichtDevice()->getSceneManager(),
			meshName
			);
	AddTransformable(mesh);
	mesh->drop();
	return mesh;
}
示例#13
0
//-----------------------------------------------------------------------------
// Debugging aid to display a texture
//-----------------------------------------------------------------------------
static void OverlayShowTexture( const char* textureName, float scale )
{
	bool			foundVar;
	IMaterial		*pMaterial;
	IMaterialVar	*BaseTextureVar;
	ITexture		*pTex;
	float			x, y, w, h;

	// ___error is created in code in CMaterialSystem::CreateDebugMaterials()
	pMaterial = materials->FindMaterial( "___error", TEXTURE_GROUP_OTHER, true );
	BaseTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false );
	if (!foundVar)
		return;

	CMatRenderContextPtr pRenderContext( materials );

	if ( textureName && textureName[0] )
	{
		pTex = materials->FindTexture( textureName, TEXTURE_GROUP_OTHER, false );
		BaseTextureVar->SetTextureValue( pTex );

		w = pTex->GetActualWidth() * scale;
		h = pTex->GetActualHeight() * scale;
	}
	else
	{
		w = h = 64.0f * scale;
	}

	// Center relative to current viewport
	int nViewportX, nViewportY, nViewportWidth, nViewportHeight;
	pRenderContext->GetViewport( nViewportX, nViewportY, nViewportWidth, nViewportHeight );
	x = ( nViewportWidth - w ) * 0.5f;
	y = ( nViewportHeight - h ) * 0.5f;

	pRenderContext->Bind( pMaterial );
	IMesh* pMesh = pRenderContext->GetDynamicMesh( true );

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
	meshBuilder.Position3f( x, y, 0.0f );
	meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
	meshBuilder.AdvanceVertex();
	meshBuilder.Position3f( x+w, y, 0.0f );
	meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
	meshBuilder.AdvanceVertex();
	meshBuilder.Position3f( x+w, y+h, 0.0f );
	meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
	meshBuilder.AdvanceVertex();
	meshBuilder.Position3f( x, y+h, 0.0f );
	meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
	meshBuilder.AdvanceVertex();
	meshBuilder.End();
	pMesh->Draw();
}
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pMaterial - 
//			source - 
//			color - 
//-----------------------------------------------------------------------------
void DrawHaloOriented( const Vector& source, float scale, float const *color, float roll )
{
	Vector point, screen;
	
	CMatRenderContextPtr pRenderContext( materials );
	IMesh* pMesh = pRenderContext->GetDynamicMesh();

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

	// Transform source into screen space
	ScreenTransform( source, screen );

	Vector right, up;
	float sr, cr;

	SinCos( roll, &sr, &cr );

	for ( int i = 0; i < 3; i++ )
	{
		right[i] = CurrentViewRight()[i] * cr + CurrentViewUp()[i] * sr;
		up[i] = CurrentViewRight()[i] * -sr + CurrentViewUp()[i] * cr;
	}

	meshBuilder.Color3fv (color);
	meshBuilder.TexCoord2f (0, 0, 1);
	VectorMA (source, -scale, up, point);
	VectorMA (point, -scale, right, point);
	meshBuilder.Position3fv (point.Base());
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3fv (color);
	meshBuilder.TexCoord2f (0, 0, 0);
	VectorMA (source, scale, up, point);
	VectorMA (point, -scale, right, point);
	meshBuilder.Position3fv (point.Base());
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3fv (color);
	meshBuilder.TexCoord2f (0, 1, 0);
	VectorMA (source, scale, up, point);
	VectorMA (point, scale, right, point);
	meshBuilder.Position3fv (point.Base());
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3fv (color);
	meshBuilder.TexCoord2f (0, 1, 1);
	VectorMA (source, -scale, up, point);
	VectorMA (point, scale, right, point);
	meshBuilder.Position3fv (point.Base());
	meshBuilder.AdvanceVertex();
	
	meshBuilder.End();
	pMesh->Draw();
}
示例#15
0
bool CModel::LoadMaterial( CXMLElement * pMaterial )
{
    CXMLAttr *		pNameAttr	= pMaterial->GetAttr( "Name" );
    const char *	szMatName	= ( NULL != pNameAttr ) ? pNameAttr->GetValue() : NULL;

    CXMLAttr *		pShader		= pMaterial->GetAttr( "Shader" );
    const char *	szShader	= ( NULL != pShader ) ? pShader->GetValue() : NULL;

    if ( !szMatName )
    {
        DEBUG_ASSERT( !"No material name!" );
        return false;
    }

    // Пробигаем по всем объектам модели, пытаемся найти
    // нужный материал по имени ( szName )
    //for ( uint n = 0; n < m_nNumObjects; ++n )
    {
        //CObject &	pObj	= m_pObjects[ n ];
        IMesh *		pMesh	= (IMesh *)m_pShape;

        IMaterial * pNewMaterial = g_pEngine->CreateMaterial();

        if ( !pNewMaterial )
        {
            // Ошибка выделения памяти
            return false;
        }

        m_pMaterial = pNewMaterial;
        pNewMaterial->SetShader( g_pRenderer->GetShader( szShader ) );

        for ( uint n = 0; n < pMesh->GetSurfCount(); ++n )
        {
            IMaterial *	pSubMat = NULL;

            if ( CStr::Compare( szMatName, pMesh->GetSurfName( n ) ) )
            {
                pSubMat = g_pEngine->CreateMaterial();

                if ( pSubMat )
                {
                    //pSubMat->SetShader( g_pRenderer->GetShader( szShader ) );
                    pSubMat->SetShader( g_pRenderer->GetShader( MESH_SHADER ) );
                }
            }

            pNewMaterial->AddSubMaterial( pSubMat );
        }

        DEBUG_ASSERT( pNewMaterial->GetSubCount() == pMesh->GetSurfCount() );
    }

    return true;
}
示例#16
0
//-----------------------------------------------------------------------------
// Purpose: Draw the jetpack level
//-----------------------------------------------------------------------------
void CHudEMP::Paint()
{
	// Rush label
	int iX, iY;
	GetPos( iX, iY );
	int iWidth = XRES(16);
	int iHeight = YRES(16);

	if ( m_pFrameVar )
	{
		float curtime = gpGlobals->curtime;

		if ( curtime >= m_flNextFrameChange )
		{
			m_flNextFrameChange = curtime + ( 1.0f / HUDEMP_FRAMERATE );

			int frame = m_pFrameVar->GetIntValue();
			frame++;
			if ( frame >= m_nNumFrames )
			{
				frame = 0;
			}
			m_pFrameVar->SetIntValue(frame);
		}
	}

	IMesh* pMesh = materials->GetDynamicMesh( true, NULL, NULL, m_pEMPIcon );

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

	meshBuilder.Color3f( 1.0, 1.0, 1.0 );
	meshBuilder.TexCoord2f( 0,0,0 );
	meshBuilder.Position3f( iX,iY,0 );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3f( 1.0, 1.0, 1.0 );
	meshBuilder.TexCoord2f( 0,1,0 );
	meshBuilder.Position3f( iX+iWidth, iY, 0 );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3f( 1.0, 1.0, 1.0 );
	meshBuilder.TexCoord2f( 0,1,1 );
	meshBuilder.Position3f( iX+iWidth, iY+iHeight, 0 );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3f( 1.0, 1.0, 1.0 );
	meshBuilder.TexCoord2f( 0,0,1 );
	meshBuilder.Position3f( iX, iY+iHeight, 0 );
	meshBuilder.AdvanceVertex();

	meshBuilder.End();
	pMesh->Draw();
}
示例#17
0
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pMaterial - 
//			source - 
//			color - 
//-----------------------------------------------------------------------------
void DrawHalo(IMaterial* pMaterial, const Vector& source, float scale, float const* color, float flHDRColorScale )
{
	static unsigned int nHDRColorScaleCache = 0;
	Vector		point, screen;
	
	if( pMaterial )
	{
		IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
		if( pHDRColorScaleVar )
		{
			pHDRColorScaleVar->SetFloatValue( flHDRColorScale );
		}
	}

	CMatRenderContextPtr pRenderContext( materials );
	IMesh* pMesh = pRenderContext->GetDynamicMesh( );

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

	// Transform source into screen space
	ScreenTransform( source, screen );

	meshBuilder.Color3fv (color);
	meshBuilder.TexCoord2f (0, 0, 1);
	VectorMA (source, -scale, CurrentViewUp(), point);
	VectorMA (point, -scale, CurrentViewRight(), point);
	meshBuilder.Position3fv (point.Base());
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3fv (color);
	meshBuilder.TexCoord2f (0, 0, 0);
	VectorMA (source, scale, CurrentViewUp(), point);
	VectorMA (point, -scale, CurrentViewRight(), point);
	meshBuilder.Position3fv (point.Base());
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3fv (color);
	meshBuilder.TexCoord2f (0, 1, 0);
	VectorMA (source, scale, CurrentViewUp(), point);
	VectorMA (point, scale, CurrentViewRight(), point);
	meshBuilder.Position3fv (point.Base());
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3fv (color);
	meshBuilder.TexCoord2f (0, 1, 1);
	VectorMA (source, -scale, CurrentViewUp(), point);
	VectorMA (point, scale, CurrentViewRight(), point);
	meshBuilder.Position3fv (point.Base());
	meshBuilder.AdvanceVertex();
	
	meshBuilder.End();
	pMesh->Draw();
}
示例#18
0
//-------------------------------------
// Loads in a mesh from a file and returns it
	// p1 in - pointer to the meshdata for the mesh
	// rv - pointer IMesh object and nullptr if failed
IMesh *CRendererOpenGL::LoadMesh(MeshData* md)
{
	IMesh *pMesh = new CMeshOpenGL();
	if( !pMesh->Load(md) )
	{
		delete pMesh;
		return nullptr;
	}
	
	m_vpMeshes.push_back(pMesh);
	return pMesh;
}
//-----------------------------------------------------------------------------
// Purpose: Renders the connecting lines between the keyframes
// Input  : pRender - 
//-----------------------------------------------------------------------------
void CMapKeyFrame::Render3D( CRender3D *pRender )
{
	if ( m_bRebuildPath )
	{
		if (GetAnimator() != NULL)
		{
			GetAnimator()->RebuildPath();
		}
	}

	// only draw if we have a valid connection
	if ( m_pNextKeyFrame && m_flSpeed > 0 )
	{
		// only draw if we haven't already been drawn this frame
		if ( GetRenderFrame() != pRender->GetRenderFrame() )
		{
			pRender->PushRenderMode( RENDER_MODE_WIREFRAME );

			SetRenderFrame( pRender->GetRenderFrame() );

			Vector o1, o2;
			GetOrigin( o1 );
			m_pNextKeyFrame->GetOrigin( o2 );

			CMeshBuilder meshBuilder;
			CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
			IMesh *pMesh = pRenderContext->GetDynamicMesh();

			// draw connecting line going from green to red
			meshBuilder.Begin( pMesh, MATERIAL_LINE_STRIP, MAX_LINE_POINTS );

			// start point
			meshBuilder.Color3f( 0, 1.0f, 0 );
			meshBuilder.Position3f( o1[0], o1[1], o1[2] );
			meshBuilder.AdvanceVertex();

			for ( int i = 0; i < MAX_LINE_POINTS; i++ )
			{
				float red = (float)(i+1) / (float)MAX_LINE_POINTS;
				meshBuilder.Color3f( red, 1.0f - red, 0 );
				meshBuilder.Position3f( m_LinePoints[i][0], m_LinePoints[i][1], m_LinePoints[i][2] );
				meshBuilder.AdvanceVertex();
			}

			meshBuilder.End();
		    pMesh->Draw();

			pRender->PopRenderMode();
		}
	}

	
}
示例#20
0
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : frame - 
//			x - 
//			y - 
//			*prcSubRect - 
//-----------------------------------------------------------------------------
void CEngineSprite::DrawFrameOfSize( int frame, int x, int y, int iWidth, int iHeight, const wrect_t *prcSubRect )
{
	// FIXME: If we ever call this with AVIs, need to have it call GetTexCoordRange and make that work
	Assert( !IsAVI() && !IsBIK() );

	float fLeft = 0;
	float fRight = 1;
	float fTop = 0;
	float fBottom = 1;

	if ( prcSubRect )
	{
		AdjustSubRect( this, frame, &fLeft, &fRight, &fTop, &fBottom, &iWidth, &iHeight, prcSubRect );
	}

	if ( giScissorTest && !Scissor( x, y, iWidth, iHeight, fLeft, fTop, fRight, fBottom ) )
		return;

	SetFrame( frame );

	CMatRenderContextPtr pRenderContext( materials );
	IMesh* pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, GetMaterial() );

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

	float color[3];
	GetHUDSpriteColor( color );
	
	meshBuilder.Color3fv( color );
	meshBuilder.TexCoord2f( 0, fLeft, fTop );
	meshBuilder.Position3f( x, y, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3fv( color );
	meshBuilder.TexCoord2f( 0, fRight, fTop );
	meshBuilder.Position3f( x + iWidth, y, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3fv( color );
	meshBuilder.TexCoord2f( 0, fRight, fBottom );
	meshBuilder.Position3f( x + iWidth, y + iHeight, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3fv( color );
	meshBuilder.TexCoord2f( 0, fLeft, fBottom );
	meshBuilder.Position3f( x, y + iHeight, 0.0f );
	meshBuilder.AdvanceVertex();

	meshBuilder.End();
	pMesh->Draw();
}
示例#21
0
//-----------------------------------------------------------------------------
// Debugging aid to display a texture
//-----------------------------------------------------------------------------
static void OverlayShowTexture( const char* textureName, float scale )
{
	bool			foundVar;
	IMaterial		*pMaterial;
	IMaterialVar	*BaseTextureVar;
	ITexture		*pTex;
	float			x, y, w, h;

	// screen safe
	x = 32;
	y = 32;

	pMaterial = materials->FindMaterial( "___debug", TEXTURE_GROUP_OTHER, true );
	BaseTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false );
	if (!foundVar)
		return;

	CMatRenderContextPtr pRenderContext( materials );

	if ( textureName && textureName[0] )
	{
		pTex = materials->FindTexture( textureName, TEXTURE_GROUP_OTHER, false );
		BaseTextureVar->SetTextureValue( pTex );

		w = pTex->GetActualWidth() * scale;
		h = pTex->GetActualHeight() * scale;
	}
	else
	{
		w = h = 64.0f * scale;
	}

	pRenderContext->Bind( pMaterial );
	IMesh* pMesh = pRenderContext->GetDynamicMesh( true );

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
	meshBuilder.Position3f( x, y, 0.0f );
	meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
	meshBuilder.AdvanceVertex();
	meshBuilder.Position3f( x+w, y, 0.0f );
	meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
	meshBuilder.AdvanceVertex();
	meshBuilder.Position3f( x+w, y+h, 0.0f );
	meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
	meshBuilder.AdvanceVertex();
	meshBuilder.Position3f( x, y+h, 0.0f );
	meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
	meshBuilder.AdvanceVertex();
	meshBuilder.End();
	pMesh->Draw();
}
TEST(Mesh, topoN2N)
{
    IMesh* msh = MeshGenerator::generateStructuredRegularQuadMesh(2.0, 2, .0, .0, .0);
    TopologyNode2NodesConnectedByEdges topo_node2nodes(*msh);

    ASSERT_EQ(topo_node2nodes.getNumberOfNodes(), msh->getNumberOfNodes());
//    size_t expected_conn_nodes0[] = {1,3};
//    size_t expected_conn_nodes1[] = {0,2,4};
//    size_t expected_conn_nodes4[] = {1,3,5,7};
//    ASSERT_EQ(std::set<size_t>(expected_conn_nodes0, expected_conn_nodes0+2), topo_node2nodes.getConnectedNodes(0));
//    ASSERT_EQ(std::set<size_t>(expected_conn_nodes1, expected_conn_nodes1+3), topo_node2nodes.getConnectedNodes(1));
//    ASSERT_EQ(std::set<size_t>(expected_conn_nodes4, expected_conn_nodes4+4), topo_node2nodes.getConnectedNodes(4));
}
示例#23
0
    /* ================================= */
    bool doit (void* ctx, commit_pipe* obj)
    {
        IMesh*              mesh;
        size_t              size;
        IAttrib*            attr;
        commit_unit*        list;
        crh3d9_cmmt_ctx*    parm;

        if (obj->effect != NULL)
            obj->effect->enter();
        size = obj->stuffz.size();
        list = obj->stuffz.data();
        parm = (crh3d9_cmmt_ctx*)ctx;
        for (size_t idx = 0; idx < size; idx++) {
            if (parm->inst != list->inst) {
                parm->inst  = list->inst;
                if (list->inst->flag == INST_FLAG_BILLBOARDV) {
                    mem_cpy(parm->main->get_mat<fp32_t>(), &parm->bllv, sizeof(mat4x4_t));
                    parm->main->mul_mat(&list->inst->tran);
                    parm->devs->SetTransform(D3DTS_WORLD, parm->main->get_mat<D3DMATRIX>());
                }
                else
                if (list->inst->flag == INST_FLAG_BILLBOARDH) {
                    mem_cpy(parm->main->get_mat<fp32_t>(), &parm->bllh, sizeof(mat4x4_t));
                    parm->main->mul_mat(&list->inst->tran);
                    parm->devs->SetTransform(D3DTS_WORLD, parm->main->get_mat<D3DMATRIX>());
                }
                else {
                    parm->devs->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&list->inst->tran));
                }
            }
            attr = list->unit->attr;
            if (attr != NULL) {
                attr->commit();
                parm->nv += attr->get_vnum();
                parm->nt += attr->get_tnum();
            }
            if (list->unit->mesh != NULL) {
                for (size_t ii = 0; ; ii++) {
                    mesh = list->unit->mesh[ii];
                    if (mesh == NULL)
                        break;
                    mesh->commit();
                    parm->nv += mesh->get_vnum();
                    parm->nt += mesh->get_tnum();
                }
            }
            list += 1;
        }
        return (true);
    }
示例#24
0
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pRender - 
//-----------------------------------------------------------------------------
void CMapLine::Render3D(CRender3D *pRender)
{
	if ( (m_pStartEntity == NULL) || (m_pEndEntity == NULL) )
		return;

	pRender->BeginRenderHitTarget(this);
	pRender->PushRenderMode(RENDER_MODE_WIREFRAME);
	
	Vector Start, End;
	
	m_pStartEntity->GetOrigin(Start);
	m_pEndEntity->GetOrigin(End);



	CMeshBuilder meshBuilder;
	CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
	IMesh* pMesh = pRenderContext->GetDynamicMesh();

	// FIXME: Can't do this...! glLineWidth(2);

	meshBuilder.Begin( pMesh, MATERIAL_LINES, 1 );

	unsigned char color[3];
	if (IsSelected())
	{
		color[0] = SELECT_EDGE_RED; 
		color[1] = SELECT_EDGE_GREEN;
		color[2] = SELECT_EDGE_BLUE;
	}
	else
	{
		color[0] = r;
		color[1] = g; 
		color[2] = b;
	}

	meshBuilder.Color3ubv( color );
	meshBuilder.Position3f(Start.x, Start.y, Start.z);
	meshBuilder.AdvanceVertex();

	meshBuilder.Color3ubv( color );
	meshBuilder.Position3f(End.x, End.y, End.z);
	meshBuilder.AdvanceVertex();

	meshBuilder.End();
	pMesh->Draw();

	pRender->EndRenderHitTarget();
	pRender->PopRenderMode();
}
示例#25
0
void FX_DrawLine( const Vector &start, const Vector &end, float scale, IMaterial *pMaterial, const color32 &color )
{
    Vector			lineDir, viewDir;
    //Get the proper orientation for the line
    VectorSubtract( end, start, lineDir );
    VectorSubtract( end, CurrentViewOrigin(), viewDir );

    Vector cross = lineDir.Cross( viewDir );

    VectorNormalize( cross );

    CMatRenderContextPtr pRenderContext( materials );

    //Bind the material
    IMesh* pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );
    CMeshBuilder meshBuilder;

    Vector			tmp;
    meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

    VectorMA( start, -scale, cross, tmp );
    meshBuilder.Position3fv( tmp.Base() );
    meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
    meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
    meshBuilder.Normal3fv( cross.Base() );
    meshBuilder.AdvanceVertex();

    VectorMA( start, scale, cross, tmp );
    meshBuilder.Position3fv( tmp.Base() );
    meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
    meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
    meshBuilder.Normal3fv( cross.Base() );
    meshBuilder.AdvanceVertex();

    VectorMA( end, scale, cross, tmp );
    meshBuilder.Position3fv( tmp.Base() );
    meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
    meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
    meshBuilder.Normal3fv( cross.Base() );
    meshBuilder.AdvanceVertex();

    VectorMA( end, -scale, cross, tmp );
    meshBuilder.Position3fv( tmp.Base() );
    meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
    meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
    meshBuilder.Normal3fv( cross.Base() );
    meshBuilder.AdvanceVertex();

    meshBuilder.End();
    pMesh->Draw();
}
示例#26
0
void Entity::updateRenderable(MeshHandle meshHandle)
{
	clearAllRenderable();
	IMesh *pMesh = gEngModule->pMeshMgr->getDataPtr(meshHandle);
	const SubMeshVec &subMeshVec = pMesh->getSubMeshVec();
	for (int i = 0; i < subMeshVec.size(); ++i)
	{
		Renderable *pRenderable = new StaticRenderable(meshHandle, i);
		addRenderable(pRenderable);
		std::string mtlName = subMeshVec[i].mtlName;
		IMaterial *pMaterial = gEngModule->pMaterialMgr->create("res/mesh/" + mtlName);
		pRenderable->setMaterial(gEngModule->pMaterialMgr->getHandle(pMaterial->getName()));
	}
}
示例#27
0
void
drawFloor ()
{
	float mTempModel[4][4];
	float mTempView[4][4];
	g_pMaterialSystem->Bind(g_materialFloor);
	g_pMaterialSystem->MatrixMode(MATERIAL_MODEL);
	g_pMaterialSystem->GetMatrix(MATERIAL_MODEL, (float*)mTempModel);
	g_pMaterialSystem->LoadIdentity();
	g_pMaterialSystem->MatrixMode(MATERIAL_VIEW);
	g_pMaterialSystem->GetMatrix(MATERIAL_VIEW, (float*)mTempView);
	g_pMaterialSystem->LoadIdentity();
	{
		IMesh* pMesh = g_pMaterialSystem->GetDynamicMesh();
		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

		float dist=-15000.0f;
		float tMin=0, tMax=1;
		
		meshBuilder.Position3f(-dist, dist, dist);
		meshBuilder.TexCoord2f( 0, tMin,tMax );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f( dist, dist, dist);
		meshBuilder.TexCoord2f( 0, tMax,tMax );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f( dist,-dist, dist);
		meshBuilder.TexCoord2f( 0, tMax,tMin );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f(-dist,-dist, dist);
		meshBuilder.TexCoord2f( 0, tMin,tMin );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.End();
		pMesh->Draw();
	}
	g_pMaterialSystem->MatrixMode(MATERIAL_MODEL);
	g_pMaterialSystem->LoadMatrix((float*)mTempModel);
	g_pMaterialSystem->MatrixMode(MATERIAL_VIEW);
	g_pMaterialSystem->LoadMatrix((float*)mTempView);
}
//! Reads attributes of the scene node.
void CMeshSceneNode::deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options)
{
	io::path oldMeshStr = SceneManager->getMeshCache()->getMeshName(Mesh);
	io::path newMeshStr = in->getAttributeAsString("Mesh");
	ReadOnlyMaterials = in->getAttributeAsBool("ReadOnlyMaterials");

	if (newMeshStr != "" && oldMeshStr != newMeshStr)
	{
		IMesh* newMesh = 0;
		IAnimatedMesh* newAnimatedMesh = SceneManager->getMesh(newMeshStr.c_str());

		if (newAnimatedMesh)
			newMesh = newAnimatedMesh->getMesh(0);

		if (newMesh)
			setMesh(newMesh);
	}

	// optional attribute to assign the hint to the whole mesh
	if (in->existsAttribute("HardwareMappingHint") &&
		in->existsAttribute("HardwareMappingBufferType"))
	{
		scene::E_HARDWARE_MAPPING mapping = scene::EHM_NEVER;
		scene::E_BUFFER_TYPE bufferType = scene::EBT_NONE;

		core::stringc smapping = in->getAttributeAsString("HardwareMappingHint");
		if (smapping.equals_ignore_case("static"))
			mapping = scene::EHM_STATIC;
		else if (smapping.equals_ignore_case("dynamic"))
			mapping = scene::EHM_DYNAMIC;
		else if (smapping.equals_ignore_case("stream"))
			mapping = scene::EHM_STREAM;

		core::stringc sbufferType = in->getAttributeAsString("HardwareMappingBufferType");
		if (sbufferType.equals_ignore_case("vertex"))
			bufferType = scene::EBT_VERTEX;
		else if (sbufferType.equals_ignore_case("index"))
			bufferType = scene::EBT_INDEX;
		else if (sbufferType.equals_ignore_case("vertexindex"))
			bufferType = scene::EBT_VERTEX_AND_INDEX;

		IMesh* mesh = getMesh();
		if (mesh)
			mesh->setHardwareMappingHint(mapping, bufferType);
	}

	IMeshSceneNode::deserializeAttributes(in, options);
}
示例#29
0
文件: main.cpp 项目: gortega56/Rig3D
    void RenderMotionBlur()
    {
        mRenderer->VSetRenderContextTargetWithDepth(mRenderContext, 0);
        mRenderer->VClearContext(mRenderContext, reinterpret_cast<const float*>(&mClearColor), 1.0f, 0);

        mRenderer->VSetInputLayout(mVertexShader);
        mRenderer->VSetVertexShader(mVertexShader);
        //	mRenderer->VSetPixelShader(mPixelShader);
        mRenderer->VSetPixelShader(mSCPixelShader);

        DrawScene();

        mRenderer->VSetContextTargetWithDepth();
        mRenderer->VClearContext(reinterpret_cast<const float*>(&mClearColor), 1.0f, 0);

        mRenderer->VSetInputLayout(mQuadVertexShader);
        mRenderer->VSetVertexShader(mQuadVertexShader);
        mRenderer->VSetPixelShader(mMotionBlurPixelShader);

        mRenderer->VUpdateShaderConstantBuffer(mBlurShaderResource, &mMBMatrixBuffer, 0);
        mRenderer->VSetPixelShaderConstantBuffer(mBlurShaderResource, 0, 0);

        mRenderer->VSetPixelShaderResourceView(mRenderContext, 0, 0);
        mRenderer->VSetPixelShaderDepthResourceView(mRenderContext, 1);
        mRenderer->VSetPixelShaderSamplerStates(mBlurShaderResource);

        mRenderer->VBindMesh(mQuadMesh);
        mRenderer->VDrawIndexed(0, mQuadMesh->GetIndexCount());

        ID3D11DeviceContext* deviceContext = mRenderer->GetDeviceContext();
        ID3D11ShaderResourceView* nullSRV[2] = { 0, 0 };
        deviceContext->PSSetShaderResources(0, 2, nullSRV);
    }
示例#30
0
	IAnimatedMesh* CMeshManager::getAnimatedMesh(const std::string& name, bool bLoadIfNotExist)
	{
		auto it = mMeshMap.find(name);
		IMesh* mesh = nullptr;
		if (it != mMeshMap.end())
			mesh = it->second;
		else if (bLoadIfNotExist)
			mesh = IResourceGroupManager::getInstance()->loadMesh(name);

		if (mesh && mesh->getType() == EMT_ANIMATE_MODEL_MESH)
		{
			return dynamic_cast<IAnimatedMesh*>(mesh);
		}

		return nullptr;
	}