Example #1
0
IMaterial *CEngineSprite::GetMaterial( RenderMode_t nRenderMode, int nFrame ) 
{
	if ( nRenderMode == kRenderNone || nRenderMode == kRenderEnvironmental )
		return NULL;

	if ( IsAVI() )
	{
		avi->SetFrame( m_hAVIMaterial, nFrame );
		return m_material[ 0 ];	// render mode is ignored for avi
	}

#if !defined( _X360 ) || defined( BINK_ENABLED_FOR_X360 )
	if ( IsBIK() )
	{
		bik->SetFrame( m_hBIKMaterial, nFrame );
		return m_material[ 0 ]; // render mode is ignored for bink
	}
#endif
	
	IMaterial *pMaterial = m_material[nRenderMode];
	Assert( pMaterial );
	if ( pMaterial == NULL )
		return NULL;

	IMaterialVar* pFrameVar = pMaterial->FindVarFast( "$frame", &frameCache );
	if ( pFrameVar )
	{
		pFrameVar->SetIntValue( nFrame );
	}

	return pMaterial;
} 
void CC_PickerShader ( const CCommand &args )
{
	C_BasePlayer *pPlayer = (C_BasePlayer *) C_BasePlayer::GetLocalPlayer();
	if ( !pPlayer )
		return;

	trace_t tr;
	Vector vecAbsStart, vecAbsEnd, vecDir;

	AngleVectors( pPlayer->EyeAngles(), &vecDir );

	vecAbsStart = pPlayer->EyePosition();
	vecAbsEnd = vecAbsStart + (vecDir * MAX_TRACE_LENGTH);

	UTIL_TraceLine( vecAbsStart, vecAbsEnd, MASK_ALL, pPlayer, COLLISION_GROUP_NONE, &tr );

	if ( tr.DidHitWorld() )
	{
		IMaterial *pMaterial = materials->FindMaterial( tr.surface.name, TEXTURE_GROUP_PRECACHED );
		if ( !IsErrorMaterial( pMaterial ) )
		{
			const char* shadername = pMaterial->GetShaderName();
			Msg("Material shader name: %s\n", shadername);
		}
		else
		{
			Msg("Could not get material shader name.\n");
		}
	}
	else
	{
		Msg("This command only supports world geometry.\n");
	}
}
Example #3
0
void RaceScene::Render()
{
	if (mDeferredShading)
	{
		mVideoDriver->setDeferredShading(false);
		//mVideoDriver->setRenderTarget(mTireTrailTexture->getRenderTarget());
		mVideoDriver->setRenderTargetAndDepthStencil(mTireTrailTexture->getRenderTarget(), mTireTrailDepthSurface);
		static const f32 color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
		mVideoDriver->clearRenderTarget(color);
		mVideoDriver->clearDepth(1.0f);

		mPlayerVehicle->renderTireTrail();
		mVideoDriver->setDefaultRenderTargetAndDepthStencil();

		IMaterial* terrainMaterial = mTerrainNode->getMaterial();
		terrainMaterial->setTexture(4, mTireTrailTexture);

		mVideoDriver->setDeferredShading(true);
		mSceneManager->drawAll();
		mVideoDriver->setDeferredShading(false);
		//mSceneManager->draw(mSceneManager->getSkyNode());
		mSceneManager->draw(4);
		
	}
	else
	{
		mVideoDriver->setDeferredShading(false);
		mSceneManager->drawAll();
	}
}
Example #4
0
IMaterial* GLGraphics::GetMaterial (const String& name, bool createIfMissing)
{
	IMaterial* mat = 0;

	if (name.IsValid())
	{
		mMaterials.Lock();
		{
			for (uint i = 0; i < mMaterials.GetSize(); ++i)
			{
				mat = mMaterials[i];

				if (mat != 0 && mat->GetName() == name)
				{
					mMaterials.Unlock();
					return mat;
				}
			}

			if (createIfMissing)
			{
				GLMaterial* glMat = new GLMaterial(name);
				glMat->_SetGraphics(this);
				mMaterials.Expand() = glMat;
				mat = glMat;
			}
			else mat = 0;
		}
		mMaterials.Unlock();
	}
	return mat;
}
Example #5
0
void CEngineSprite::SetFrame( RenderMode_t nRenderMode, int nFrame )
{
	if ( IsAVI() )
	{
		avi->SetFrame( m_hAVIMaterial, nFrame );
		return;
	}

#if !defined( _X360 ) || defined( BINK_ENABLED_FOR_X360 )
	if ( IsBIK() )
	{
		bik->SetFrame( m_hBIKMaterial, nFrame );
		return;
	}
#endif

	IMaterial *pMaterial = m_material[nRenderMode];
	if ( !pMaterial )
		return;

	IMaterialVar* pFrameVar = pMaterial->FindVarFast( "$frame", &frameCache );
	if ( pFrameVar )
	{
		pFrameVar->SetIntValue( nFrame );
	}
}
    void CCoherentUISystem::ChangeEntityDiffuseTextureForMaterial( CCoherentViewListener* pViewListener, const char* entityName, const char* materialName )
    {
        IMaterial* pMaterial = gEnv->p3DEngine->GetMaterialManager()->FindMaterial( materialName );
        IEntity* pEntity = gEnv->pEntitySystem->FindEntityByName( entityName );

        if ( pEntity && !pMaterial )
        {
            pMaterial = pEntity->GetMaterial();
        }

        if ( pMaterial )
        {
            STexSamplerRT& sampler = pMaterial->GetShaderItem().m_pShaderResources->GetTexture( EFTT_DIFFUSE )->m_Sampler;

            // Create a new texture and scrap the old one
            void* pD3DTextureDst = NULL;
            ITexture* pCryTex = gD3DSystem->CreateTexture(
                                    &pD3DTextureDst,
                                    sampler.m_pITex->GetWidth(),
                                    sampler.m_pITex->GetHeight(),
                                    1,
                                    eTF_A8R8G8B8,
                                    FT_USAGE_DYNAMIC
                                );

            int oldTextureID = sampler.m_pITex->GetTextureID();
            gEnv->pRenderer->RemoveTexture( oldTextureID );
            sampler.m_pITex = pCryTex;
            pCryTex->AddRef();

            pViewListener->SetTexture( pD3DTextureDst, pCryTex->GetTextureID() );
        }
    }
//-----------------------------------------------------------------------------
// Purpose: Updates and renders all effects
//-----------------------------------------------------------------------------
int C_HopwireExplosion::DrawModel( int flags )
{
	AddParticles();

#ifndef C17
	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->Flush();
	UpdateRefractTexture();

	IMaterial *pMat = materials->FindMaterial( "effects/strider_pinch_dudv", TEXTURE_GROUP_CLIENT_EFFECTS );

	float refract = m_FXCoreAlpha.Interp( gpGlobals->curtime );
	float scale = m_FXCoreScale.Interp( gpGlobals->curtime );

	IMaterialVar *pVar = pMat->FindVar( "$refractamount", NULL );
	pVar->SetFloatValue( refract );

	pRenderContext->Bind( pMat, (IClientRenderable*)this );
	
	float sin1 = sinf( gpGlobals->curtime * 10 );
	float sin2 = sinf( gpGlobals->curtime );

	float scaleY = ( sin1 * sin2 ) * 32.0f;
	float scaleX = (sin2 * sin2) * 32.0f;

	// FIXME: The ball needs to sort properly at all times
	static color32 white = {255,255,255,255};
	DrawSpriteTangentSpace( GetRenderOrigin() + ( CurrentViewForward() * 128.0f ), scale+scaleX, scale+scaleY, white );
#endif

	return 1;
}
// Level init, shutdown
void CPixelVisibilitySystem::LevelInitPreEntity()
{
	bool fastqueries = HasFastQueries();
	// printf("\n ** fast queries: %s **", fastqueries?"true":"false" );
	
	m_hwCanTestGlows = r_dopixelvisibility.GetBool() && fastqueries && engine->GetDXSupportLevel() >= 80;
	if ( m_hwCanTestGlows )
	{
		CMatRenderContextPtr pRenderContext( materials );

		OcclusionQueryObjectHandle_t query = pRenderContext->CreateOcclusionQueryObject();
		if ( query != INVALID_OCCLUSION_QUERY_OBJECT_HANDLE )
		{
			pRenderContext->DestroyOcclusionQueryObject( query );
		}
		else
		{
			m_hwCanTestGlows = false;
		}
	}

	m_pProxyMaterial = materials->FindMaterial("engine/occlusionproxy", TEXTURE_GROUP_CLIENT_EFFECTS);
	m_pProxyMaterial->IncrementReferenceCount();
	m_pDrawMaterial = materials->FindMaterial("engine/occlusionproxy_countdraw", TEXTURE_GROUP_CLIENT_EFFECTS);
	m_pDrawMaterial->IncrementReferenceCount();
	m_freeQueriesList = m_queryList.CreateList();
	m_activeSetsList = m_setList.CreateList();
	m_freeSetsList = m_setList.CreateList();
}
//-----------------------------------------------------------------------------
// Purpose: Load any materials that reference this texture. Used so we can refresh a 
// material's preview image if a relevant .vtf changes.
//-----------------------------------------------------------------------------
void CTextureSystem::ReloadMaterialsUsingTexture( ITexture *pTestTexture )
{
	for ( int i=0; i < m_Textures.Count(); i++ )
	{
		IEditorTexture *pEditorTex = m_Textures[i];
		IMaterial *pMat = pEditorTex->GetMaterial( false );
		if ( !pMat )
			continue;
		
		IMaterialVar **pParams = pMat->GetShaderParams();
		int nParams = pMat->ShaderParamCount();
		for ( int iParam=0; iParam < nParams; iParam++ )
		{
			if ( pParams[iParam]->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
				continue;
			
			ITexture *pTex = pParams[iParam]->GetTextureValue();
			if ( !pTex )
				continue;
			
			if ( pTex == pTestTexture )
			{
				pEditorTex->Reload( true );
			}
		}
	}
}
Example #10
0
void HSV_Select_SV::Paint()
{
    surface()->DrawSetTexture(m_iMat);
    surface()->DrawSetColor(Color(255, 255, 255, 255));
    int x, y, sx, sy;
    GetBounds(x, y, sx, sy);

    Vertex_t points[4];
    points[0].m_TexCoord.Init(0, 0);
    points[1].m_TexCoord.Init(1, 0);
    points[2].m_TexCoord.Init(1, 1);
    points[3].m_TexCoord.Init(0, 1);

    IMaterial *pMatColorpicker = materials->FindMaterial("vgui/colorpicker", TEXTURE_GROUP_OTHER);
    if (IsErrorMaterial(pMatColorpicker))
        return;
    bool bFound = false;
    IMaterialVar *pVar_00 = pMatColorpicker->FindVar("$COLOR_00", &bFound);
    IMaterialVar *pVar_10 = pMatColorpicker->FindVar("$COLOR_10", &bFound);
    IMaterialVar *pVar_11 = pMatColorpicker->FindVar("$COLOR_11", &bFound);
    IMaterialVar *pVar_01 = pMatColorpicker->FindVar("$COLOR_01", &bFound);
    if (!bFound)
        return;

    Vector col;
    HSV2RGB(m_flH, 1, 1, col);

    pVar_00->SetVecValue(1, 1, 1);
    pVar_10->SetVecValue(col.Base(), 3);
    pVar_11->SetVecValue(0, 0, 0);
    pVar_01->SetVecValue(0, 0, 0);

    surface()->DrawTexturedRect(0, 0, sx, sy);
}
//--------------------------------------------------------------------------------------------------
// Name: CacheItemModel
// Desc: Cache item model
//--------------------------------------------------------------------------------------------------
void CFrontEndModelCache::CacheItemModel(const char* pItemName)
{
	CItemSharedParams* pItemSharedParams = g_pGame->GetGameSharedParametersStorage()->GetItemSharedParameters(pItemName, false);
	if(pItemSharedParams)
	{
		const SGeometryDef* pGeomDef = pItemSharedParams->GetGeometryForSlot(eIGS_ThirdPerson);

		if(pGeomDef)
		{
			const char* pModelFileName = pGeomDef->modelPath.c_str();
			FE_LOG ("Caching \"%s\" (for item '%s')", pModelFileName, pItemName);
			INDENT_LOG_DURING_SCOPE();
			m_myGeometryCache.CacheGeometry(pModelFileName, false, IStatObj::ELoadingFlagsIgnoreLoDs);

			const char *pMaterialName = pGeomDef->material.c_str();
			FE_LOG("  caching material '%s'", pMaterialName);
			IMaterial* pMaterial = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(pMaterialName);
			if(pMaterial)
			{
				m_materialCache.push_back(pMaterial);
				pMaterial->RequestTexturesLoading(0.0f);
			}
		}
	}
	else
	{
		GameWarning("Failed to find shared parameters for item '%s' - can't cache model", pItemName);
	}
}//-------------------------------------------------------------------------------------------------
	void OpenGLRenderManager::doRender(IVertexBuffer* _buffer, ITexture* _texture, size_t _count)
	{
		UIRenderable* pUIRenderable = static_cast<UIRenderable*>(_buffer);
		//unsigned int buffer_id = buffer->getBufferID();
		//MYGUI_PLATFORM_ASSERT(buffer_id, "Vertex buffer is not created");

		/*unsigned int texture_id = 0;
		if (_texture)
		{
			MyGuiOpenGLTexture* texture = static_cast<MyGuiOpenGLTexture*>(_texture);
			texture_id = texture->getTextureID();
			//MYGUI_PLATFORM_ASSERT(texture_id, "Texture is not created");
		}

		glBindTexture(GL_TEXTURE_2D, texture_id);*/
		MyGuiOpenGLTexture* texture = static_cast<MyGuiOpenGLTexture*>(_texture);
		texture->bind();

		//create material
		//std::string matName = pUIRenderable->getName();
		//matName.append(" mat");
		IMaterial *pMat = gEngModule->pMaterialMgr->create("Res/mat_util/ui.mtl");
		pMat->setTexture(texture->getTexHandle(), 0);
		pUIRenderable->setMaterial(gEngModule->pMaterialMgr->getHandle("Res/mat_util/ui.mtl"));
		pUIRenderable->setRenderIndexValue(_count);
		gEngModule->pRenderSequence->pushToRenderSequence(pUIRenderable, RENDER_LAYER_UI);
		
	}
void CASWHudCrosshair::DrawSniperScope( int x, int y )
{
	C_ASW_Player *pPlayer = C_ASW_Player::GetLocalASWPlayer();
	if ( !pPlayer )
		return;	

	C_ASW_Marine *pMarine = pPlayer->GetMarine();
	if ( !pMarine )
		return;

	const int NUM_CIRCLE_POINTS = 40;
	static vgui::Vertex_t points[ NUM_CIRCLE_POINTS ];
	float width = YRES( asw_sniper_scope_radius.GetFloat() );
	float height = YRES( asw_sniper_scope_radius.GetFloat() );
	for ( int i = 0; i < NUM_CIRCLE_POINTS; i++ )
	{
		float flAngle = 2.0f * M_PI * ( (float) i / (float) NUM_CIRCLE_POINTS );
		points[ i ].Init( Vector2D( x + width * cos( flAngle ), y + height * sin( flAngle ) ), Vector2D( 0.5f + 0.5f * cos( flAngle ), 0.5f + 0.5f * sin( flAngle ) ) );
	}
	surface()->DrawSetColor( Color(255,255,255,255) );
	surface()->DrawSetTexture( m_nSniperMagnifyTexture );
	IMaterial *pMaterial = materials->FindMaterial( "effects/magnifyinglens", TEXTURE_GROUP_OTHER );
	IMaterialVar *pMagnificationCenterVar = pMaterial->FindVar( "$magnifyCenter", NULL );
	
	float flCenterX = ( ( float )x / ( float )ScreenWidth() ) - 0.5f;
	float flCenterY = ( ( float )y / ( float )ScreenHeight() ) - 0.5f;
	pMagnificationCenterVar->SetVecValue( flCenterX, flCenterY, 0, 0 );	

	vgui::surface()->DrawTexturedPolygon( NUM_CIRCLE_POINTS, points );
}
Example #14
0
void CSceneManager::collectMeshNodeShaders(IMeshNode* node)
{
	// collect all the shaders ( for per-frame variables optimization)
	u32 subsetCount = node->getSubsetCount();
	for (u32 i = 0; i < subsetCount; i++)
	{
		IMaterial* material = node->getMaterial(i);
		if (material)
		{
			for (u32 j = 0; j < material->getPipelineCount(); j++)
			{
				IPipeline* pipeline = material->getPipeline(j);
				if (pipeline)
				{
					for (u32 k = 0; k < EST_SHADER_COUNT; k++)
					{
						IShader* shader = pipeline->getShader((E_SHADER_TYPE)k);
						if (shader != nullptr)
							mActiveShaders.insert(shader);
					}
				}
			}
		}
	}
}
Example #15
0
void Entity::setMaterial(const std::string &name)
{
	//setMaterial(name, 0);
	IMaterialMgr *pMatMgr = gEngModule->pMaterialMgr;
	MaterialHandle handle = pMatMgr->getHandle(name);
	IMaterial *pMat = 0;
	if (handle.isNull() == true)
	{
		IMaterial *pCreateMat = pMatMgr->create(name);
		if (pCreateMat != 0)
		{
			mMaterialHandle = pMatMgr->getHandle(name);
			pMat = pCreateMat;
		}
	}

	for (int i = 0; i < mSubRenderableVec.size(); ++i)
	{
		if (i == 0)
		{
			mSubRenderableVec[i]->setMaterial(mMaterialHandle);
		}
		else
		{
			SubMaterialVec subMaterialVec = pMat->getSubMaterialVec();
			IMaterial *pSubMat = subMaterialVec[i - 1];
			mSubRenderableVec[i]->setMaterial(pSubMat->getName());
		}
	}
}
bool CCamoMaterialProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
	return false; // hack!  Need to make sure that the TGA loader has a valid filesystem before trying
			// to load the camo pattern.

#if 0
	// set how big our instance data is.
	SetInstanceDataSize( sizeof( CamoInstanceData_t ) );
#endif
	// remember what material we belong to.
	m_pMaterial = pMaterial;
	// get pointers to material vars.
	bool found;
	m_pCamoTextureVar = m_pMaterial->FindVar( "$baseTexture", &found );
	if( !found )
	{
		m_pCamoTextureVar = NULL;
		return false;
	}
	ITexture *pCamoTexture = m_pCamoTextureVar->GetTextureValue();
	if (pCamoTexture)
		pCamoTexture->SetTextureRegenerator( &m_TextureRegen );
	
	// Need to get the palettized texture to create the procedural texture from
	// somewhere.
	m_pCamoPatternTextureVar = m_pMaterial->FindVar( "$camoPatternTexture", &found );
	if( !found )
	{
		m_pCamoTextureVar = NULL;
		return false;
	}
	
	IMaterialVar *subBoundingBoxMinVar, *subBoundingBoxMaxVar;

	subBoundingBoxMinVar = m_pMaterial->FindVar( "$camoBoundingBoxMin", &found, false );
	if( !found )
	{
		m_SubBoundingBoxMin = Vector( 0.0f, 0.0f, 0.0f );
	}
	else
	{
		subBoundingBoxMinVar->GetVecValue( m_SubBoundingBoxMin.Base(), 3 );
	}

	subBoundingBoxMaxVar = m_pMaterial->FindVar( "$camoBoundingBoxMax", &found, false );
	if( !found )
	{
		m_SubBoundingBoxMax = Vector( 1.0f, 1.0f, 1.0f );
	}
	else
	{
		subBoundingBoxMaxVar->GetVecValue( m_SubBoundingBoxMax.Base(), 3 );
	}
	
	LoadCamoPattern();
	GenerateRandomPointsInNormalizedCube();

	return true;
}
//------------------------------------------------------------------------------
// Purpose : Create leak effect if material requests it
// Input   :
// Output  :
//------------------------------------------------------------------------------
void LeakEffect( trace_t &tr )
{
	Vector			diffuseColor, baseColor;
	Vector			vTraceDir	= (tr.endpos - tr.startpos);
	VectorNormalize(vTraceDir);
	Vector			vTraceStart = tr.endpos - 0.1*vTraceDir;
	Vector			vTraceEnd	= tr.endpos + 0.1*vTraceDir;
	IMaterial*		pTraceMaterial = engine->TraceLineMaterialAndLighting( vTraceStart, vTraceEnd, diffuseColor, baseColor );

	if (!pTraceMaterial)
		return;

	bool			found;
	IMaterialVar	*pLeakVar = pTraceMaterial->FindVar( "$leakamount", &found, false );
	if( !found )
		return;

	C_Splash* pLeak = new C_Splash();
	if (!pLeak)
		return;

	ClientEntityList().AddNonNetworkableEntity( pLeak->GetIClientUnknown() );

	IMaterialVar*	pLeakColorVar = pTraceMaterial->FindVar( "$leakcolor", &found );
	if (found)
	{
		Vector color;
		pLeakColorVar->GetVecValue(color.Base(),3);
		pLeak->m_vStartColor = pLeak->m_vEndColor = color;
	}

	IMaterialVar*	pLeakNoiseVar = pTraceMaterial->FindVar( "$leaknoise", &found );
	if (found)
	{
		pLeak->m_flNoise = pLeakNoiseVar->GetFloatValue();
	}

	IMaterialVar*	pLeakForceVar = pTraceMaterial->FindVar( "$leakforce", &found );
	if (found)
	{
		float flForce = pLeakForceVar->GetFloatValue();
		pLeak->m_flSpeed		 = flForce;
		pLeak->m_flSpeedRange	 = pLeak->m_flNoise * flForce;
	}

	pLeak->m_flSpawnRate		= pLeakVar->GetFloatValue();;
	pLeak->m_flParticleLifetime = 10;
	pLeak->m_flWidthMin			= 1;
	pLeak->m_flWidthMax			= 5;
	pLeak->SetLocalOrigin( tr.endpos );
	
	QAngle angles;
	VectorAngles( tr.plane.normal, angles );
	pLeak->SetLocalAngles( angles );

	pLeak->Start(&g_ParticleMgr, NULL);
	pLeak->m_flStopEmitTime	= gpGlobals->curtime+5.0;
	pLeak->SetNextClientThink(gpGlobals->curtime+20.0);
}
Example #18
0
void NoSmoke::Cleanup()
{
	for (auto material_name : smoke_materials)
	{
		IMaterial* mat = material->FindMaterial(material_name, TEXTURE_GROUP_OTHER);
		mat->SetMaterialVarFlag(MATERIAL_VAR_NO_DRAW, false);
	}
}
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pDC - 
//			dstRect - 
//			detectErrors - 
//-----------------------------------------------------------------------------
void CMaterial::DrawBrowserIcons( CDC *pDC, RECT& dstRect, bool detectErrors )
{
	static CMaterial* pTranslucentIcon = 0;
	static CMaterial* pOpaqueIcon = 0;
	static CMaterial* pSelfIllumIcon = 0;
	static CMaterial* pBaseAlphaEnvMapMaskIcon = 0;
	static CMaterial* pErrorIcon = 0;

	if (!pTranslucentIcon)
	{
		pTranslucentIcon			= CreateMaterial("editor/translucenticon", true);
		pOpaqueIcon					= CreateMaterial("editor/opaqueicon", true);
		pSelfIllumIcon				= CreateMaterial("editor/selfillumicon", true);
		pBaseAlphaEnvMapMaskIcon	= CreateMaterial("editor/basealphaenvmapmaskicon", true);
		pErrorIcon					= CreateMaterial("editor/erroricon", true);

		Assert( pTranslucentIcon && pOpaqueIcon && pSelfIllumIcon && pBaseAlphaEnvMapMaskIcon && pErrorIcon );
	}

	bool error = false;

	IMaterial* pMaterial = GetMaterial();
	if ( pMaterial->GetMaterialVarFlag( MATERIAL_VAR_TRANSLUCENT ) )
	{
		DrawIcon( pDC, pTranslucentIcon, dstRect );
		if (detectErrors)
		{
			error = error || !m_TranslucentBaseTexture; 
		}
	}
	else
	{
		DrawIcon( pDC, pOpaqueIcon, dstRect ); 
	}

	if ( pMaterial->GetMaterialVarFlag( MATERIAL_VAR_SELFILLUM ))
	{
		DrawIcon( pDC, pSelfIllumIcon, dstRect ); 
		if (detectErrors)
		{
			error = error || !m_TranslucentBaseTexture;
		}
	}

	if ( pMaterial->GetMaterialVarFlag( MATERIAL_VAR_BASEALPHAENVMAPMASK ))
	{
		DrawIcon( pDC, pBaseAlphaEnvMapMaskIcon, dstRect ); 
		if (detectErrors)
		{
			error = error || !m_TranslucentBaseTexture;
		}
	}

	if (error)
	{
		DrawIcon( pDC, pErrorIcon, dstRect );
	}
}
Example #20
0
	void D3DRenderContext::AddToRenderingQueue(const IRenderable* renderableObjectPtr) {
		IMaterial* materialPtr = renderableObjectPtr->GetMaterial();
		if (renderableObjectPtr->HasAlpha()) {
			m_alphaObjectsQueue[renderableObjectPtr->GetZ()][materialPtr->GetMaterialId()].push_back(renderableObjectPtr);
		} else {
			m_solidObjectsQueue[materialPtr->GetMaterialId()].push_back(renderableObjectPtr);
		}
		m_materials[materialPtr->GetMaterialId()] = materialPtr;
	}
//-----------------------------------------------------------------------------
// Purpose: relayouts out the panel after any internal changes
//-----------------------------------------------------------------------------
void CMaterialViewPanel::PerformLayout()
{
	// Get the current size, see if it's big enough to view the entire thing
	int iWidth, iHeight;
	GetSize( iWidth, iHeight );

	// In the case of stretching, just stretch to the size and blow off
	// the scrollbars. Same holds true if there's no material
	if (!m_bUseActualSize || !m_pMaterial)
	{
		m_iViewableWidth = iWidth;
		m_iViewableHeight = iHeight;
		m_pHorizontalBar->SetVisible(false);
		m_pVerticalBar->SetVisible(false);
		return;
	}

	// Check the size of the material...
	int iMaterialWidth = m_pMaterial->GetMappingWidth();
	int iMaterialHeight = m_pMaterial->GetMappingHeight();

	// Check if the scroll bars are visible
	bool bHorizScrollVisible = (iMaterialWidth > iWidth);
	bool bVertScrollVisible = (iMaterialHeight > iHeight);

	m_pHorizontalBar->SetVisible(bHorizScrollVisible);
	m_pVerticalBar->SetVisible(bVertScrollVisible);

	// Shrink the bars if both are visible
	m_iViewableWidth = bVertScrollVisible ? iWidth - SCROLLBAR_SIZE - WINDOW_BORDER_WIDTH : iWidth; 
	m_iViewableHeight = bHorizScrollVisible ? iHeight - SCROLLBAR_SIZE - WINDOW_BORDER_WIDTH : iHeight; 

	// Set the position of the horizontal bar...
	if (bHorizScrollVisible)
	{
		m_pHorizontalBar->SetPos(0, iHeight - SCROLLBAR_SIZE);
		m_pHorizontalBar->SetSize( m_iViewableWidth, SCROLLBAR_SIZE );

		m_pHorizontalBar->SetRangeWindow( m_iViewableWidth );
		m_pHorizontalBar->SetRange( 0, iMaterialWidth );	

		// FIXME: Change scroll amount based on how much is not visible?
		m_pHorizontalBar->SetButtonPressedScrollValue( 5 );
	}

	// Set the position of the vertical bar...
	if (bVertScrollVisible)
	{
		m_pVerticalBar->SetPos(iWidth - SCROLLBAR_SIZE, 0);
		m_pVerticalBar->SetSize(SCROLLBAR_SIZE, m_iViewableHeight);

		m_pVerticalBar->SetRangeWindow( m_iViewableHeight );
		m_pVerticalBar->SetRange( 0, iMaterialHeight);	
		m_pVerticalBar->SetButtonPressedScrollValue( 5 );
	}
}
//-----------------------------------------------------------------------------
// Material precache
//-----------------------------------------------------------------------------
void CHLClient::PrecacheMaterial( const char *pMaterialName )
{
	bool bFound;
	IMaterial *pMaterial = materials->FindMaterial( pMaterialName, &bFound );
	if ( bFound && pMaterial )
	{
		pMaterial->IncrementReferenceCount();
		m_CachedMaterials.AddToTail( pMaterial );
	}
}
Example #23
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();
}
void CGameVolume_Water::SetupVolume()
{
	IGameVolumes::VolumeInfo volumeInfo;
	if (GetVolumeInfoForEntity(GetEntityId(), volumeInfo) == false)
		return;

	if (volumeInfo.verticesCount < 3)
		return;

	WaterProperties waterProperties(GetEntity()); 

	if(waterProperties.isRiver)
	{
		if(volumeInfo.verticesCount < 4 || volumeInfo.verticesCount % 2 != 0)
			return;

		int numSegments = (volumeInfo.verticesCount / 2) - 1;

		m_segments.resize(numSegments);

		for(int i = 0; i < numSegments; ++i)
		{
			SetupVolumeSegment(waterProperties, i, &volumeInfo.pVertices[0], volumeInfo.verticesCount);
		}
	}
	else
	{
		SetupVolumeSegment(waterProperties, 0, &volumeInfo.pVertices[0], volumeInfo.verticesCount);
	}

#if CRY_PLATFORM_WINDOWS && !defined(_RELEASE)
	{
		if (gEnv->IsEditor())
		{
			IEntity* pEnt = GetEntity();
			IMaterial* pMat = pEnt ? pEnt->GetMaterial() : 0;
			if (pMat)
			{
				const SShaderItem& si = pMat->GetShaderItem();
				if (si.m_pShader && si.m_pShader->GetShaderType() != eST_Water)
				{
					CryWarning(VALIDATOR_MODULE_3DENGINE, VALIDATOR_ERROR, "Incorrect shader set for water / water fog volume \"%s\"!", pEnt->GetName());
				}
			}
		}
	}
#endif

	m_baseMatrix = GetEntity()->GetWorldTM();
	m_initialMatrix = m_baseMatrix;
	m_volumeDepth = waterProperties.depth;
	m_streamSpeed = waterProperties.streamSpeed;
	m_awakeAreaWhenMoving = waterProperties.awakeAreaWhenMoving;
	m_isRiver = waterProperties.isRiver;
}
IMaterial* IMaterialManager::CreateMaterial(N_UID matName,const N_MaterialDesc& matDesc)
{
	if (matName == mDefaultMatName)
	{
		ERROR_MSG("CreateMaterial: uid occupied (by default material, how lucky you are- -.)");
		return nullptr;
	}

	IMaterial* pMat = IFactory<IMaterial>::CreateObject(matName);
	pMat->SetDesc(matDesc);
	return pMat;
}
Example #26
0
bool CResourceLoader::loadMaterial(const std::string& fullpath, 
	const IResourceXmlParser::SMaterialCreateParams& createParams) const
{
	IMaterial* material = mMaterialManager->get(createParams.Name);
	if (material)
	{
		GF_PRINT_CONSOLE_INFO("Material '%s' (in the file '%s') has already been loaded. It can't been loaded again. \
					Do you put materials with same names in material files ?\n",
					createParams.Name.c_str(), fullpath.c_str());
		return false;
	}

	IPipeline* pipelines[8];

	for (u32 i = 0; i < createParams.PipelineNames.size(); i++)
	{
		const std::string& pipelineName = createParams.PipelineNames[i];
		IPipeline* pipeline = mPipelineManager->get(pipelineName);
		if (!pipeline)
		{
			GF_PRINT_CONSOLE_INFO("The pipeline named '%s' doesn't exist in material '%s' (file location: %s).\n",
				pipelineName.c_str(), createParams.Name.c_str(), fullpath.c_str());
			return false;
		}

		pipelines[i] = pipeline;
	}

	material = mMaterialManager->create(createParams.Name, createParams.MaterialColors,
		pipelines, createParams.PipelineNames.size());

	if (!material)
	{
		GF_PRINT_CONSOLE_INFO("The material named '%s' created failed! ( file location: %s ).\n",
			createParams.Name.c_str(), fullpath.c_str());
		return false;
	}

	for (u32 i = 0; i < createParams.TextureParams.size(); i++)
	{
		ITexture* texture = mTextureManager->get(createParams.TextureParams[i].Name);
		if (!texture)
		{
			GF_PRINT_CONSOLE_INFO("Texture '%s' doesn't exist in material '%s'. (file location: %s).\n",
				createParams.TextureParams[i].Name.c_str(), createParams.Name.c_str(), fullpath.c_str());
		}
		else
		{
			material->setTexture(createParams.TextureParams[i].Index, texture);
		}
	}
	return true;
}
//-----------------------------------------------------------------------------
// Creates, destroys particles attached to an attachment
//-----------------------------------------------------------------------------
void C_EnvParticleScript::CreateParticle( const char *pAttachmentName, const char *pSpriteName )
{
	// Find the attachment
	int nAttachment = LookupAttachment( pAttachmentName );
	if ( nAttachment <= 0 )
		return;

	// Get the sprite materials
	PMaterialHandle hMat = m_ParticleEffect.FindOrAddMaterial( pSpriteName );
	ParticleScriptParticle_t *pParticle = 
		(ParticleScriptParticle_t*)m_ParticleEffect.AddParticle(sizeof(ParticleScriptParticle_t), hMat);

	if ( pParticle == NULL )
		return;
	
	// Get the sprite size from the material's materialvars
	bool bFound = false;
	IMaterialVar *pMaterialVar = NULL;
	IMaterial *pMaterial = ParticleMgr()->PMaterialToIMaterial( hMat );
	if ( pMaterial )
	{
		pMaterialVar = pMaterial->FindVar( "$spritesize", &bFound, false );
	}

	if ( bFound )
	{
		pParticle->m_flSize = pMaterialVar->GetFloatValue();
	}
	else
	{
		pParticle->m_flSize = 100.0f;
	}

	// Make sure the particle cull size reflects our particles
	if ( pParticle->m_flSize > m_flMaxParticleSize )
	{
		m_flMaxParticleSize = pParticle->m_flSize;
		m_ParticleEffect.SetParticleCullRadius( m_flMaxParticleSize );
	}

	// Place the particle on the attachment specified
	pParticle->m_nAttachment = nAttachment;
	QAngle vecAngles;
	GetAttachment( nAttachment, pParticle->m_Pos, vecAngles );

	if ( m_flSequenceScale != 1.0f )
	{
		pParticle->m_Pos -= GetAbsOrigin();
		pParticle->m_Pos *= m_flSequenceScale;
		pParticle->m_Pos += GetAbsOrigin();
	}
}
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : filter - 
//			delay - 
//			pos - 
//			player - 
//			entity - 
//-----------------------------------------------------------------------------
void TE_PlayerDecal( IRecipientFilter& filter, float delay,
	const Vector* pos, int player, int entity  )
{
	if ( cl_playerspraydisable.GetBool() )
		return;

	// No valid target?
	C_BaseEntity *ent = cl_entitylist->GetEnt( entity );
	if ( !ent )
		return;

	// Find player logo for shooter
	player_info_t info;
	engine->GetPlayerInfo( player, &info );

	// Make sure we've got the material for this player's logo
	char texname[ 512 ];
	IMaterial *logo = CreateTempMaterialForPlayerLogo( player, &info, texname, 512 );
	if ( !logo )
		return;

	ITexture *texture = materials->FindTexture( texname, TEXTURE_GROUP_DECAL );
	if ( IsErrorTexture( texture ) ) 
	{
		return; // not found 
	}

	// Update the texture used by the material if need be.
	bool bFound = false;
	IMaterialVar *pMatVar = logo->FindVar( "$basetexture", &bFound );
	if ( bFound && pMatVar )
	{
		if ( pMatVar->GetTextureValue() != texture )
		{
			pMatVar->SetTextureValue( texture );
			logo->RefreshPreservingMaterialVars();
		}
	}

	color32 rgbaColor = { 255, 255, 255, 255 };
	effects->PlayerDecalShoot( 
		logo, 
		(void *)player,
		entity, 
		ent->GetModel(), 
		ent->GetAbsOrigin(), 
		ent->GetAbsAngles(), 
		*pos, 
		0, 
		0,
		rgbaColor );
}
Example #29
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();
}
void CPixelVisibilitySystem::LevelShutdownPostEntity()
{
	m_pProxyMaterial->DecrementReferenceCount();
	m_pProxyMaterial = NULL;
	m_pDrawMaterial->DecrementReferenceCount();
	m_pDrawMaterial = NULL;
	DeleteUnusedSets(true);
	m_setList.Purge();
	m_queryList.Purge();
	m_freeQueriesList = m_queryList.InvalidIndex();
	m_activeSetsList = m_setList.InvalidIndex();
	m_freeSetsList = m_setList.InvalidIndex();
}