Procedural Materials

unfaithful holiday reviews porno films jobs part time porno web cam www amr khaled mobile ringtones craigslist nyc kodak digital cameras tavist corporate tax planning used car value payday flower emule server list brats games gay porn bad credit unsecured loans after bankruptcy housewife cheap hotels amsterdam the disney store dating woman gta san andreas hentia games used hotel furniture bad credit personal loan oakley m frame replicas free full length adult movies 2wire usb remote ndis ethernet gambling link criminal background check joann fabric motorcycle seats are nudists free mp3 music downloads celine dion electric motor sammy sosa blood tests lynn swann for governor corporal punishment hot naked woman capital one secured credit card essential oil t mobile picture hot hot sex shave pussy cheap plane ticket nasdaq online stock trading bridal dress weight loss pills sleeper chair income bonds interest rates on savings lisinopril side effects ls-model fat thick women free online dating site crack do powerdvd 6 trial kyocera ringtones willy wonka chocolate factory volvo v70 istanbul home jobs geforce fx 5500 drivers pokemon may asacol spy erotic lingerie secret shopper job online pharmacy australia proxy server list food poisoning braided rug water heater relationship compatibility life fitness 9500hr machine fuck matrix personal webcam site ovulation calculator jewelry list of military high schools foot stools unique halloween costume south park chinese calender cars rental gucci-handbags public sex movies nissan skyline sale simply accounting free to air list of all airlines nude old grannies sidecar porn for free bridal bouquets fresh flower game sex mercury mountaineer beautiful arab girls tummy tuck how much weight do i need to lose hot xxx sex schizophrenia krystal steal prescription drug addiction ashley furniture timex watches fotos sexo free printable bookmarks children mp3 ringtones doxycycline vibramycin ketoconazole animal zoo payless shoe source thomasville furniture mindy vega clonidine short dress throw pillows havaianas bebes michel viet suzuki swifts cell look phone reverse up religion free swinger personal homepages mexican discount pharmacy merchant accounts teenporno american girls antivirus sofa first national bank hermitage pa free realtones buy houses asian dating online tickle me elmo surprise winter wedding dress game shows chanel caviar handbag pictures of pyramids we live together amsouth bank cover letters bangkok hotels buy ephedrine clip on watch norton systemworks adult friend finder underskirt alltel free ringtones chrysler car dealer medullary cancer hot blonde personal care gougle gratuit orgasm squirting lesbians kissing restaurant coupons princeton nj boston college calgary job shop cameltoe-forum criminal checks urban rebound coach designer shoes dodgeram levoxyl bad credit mortgage refinance prilosec airline ticket bid employee payroll spreadsheet triumph lingerie tiger woods wife bass shoes outlet origin of name spy bot bondage directory asian women for marriage pokemon card free cartoon porn video overseas online pharmacy free download able music mobile home free mp3 song download alaska airline flight information data recovery pain med hentai videos electric blankets air tran airline reservation bars beretta washington mutual bank cd rate cellular phones tila extenze madonna tickets Procedural materials allow you to change the image at the pixel level during runtime. To create a procedural material you will need 4 things. You will need a VMT file to define the texture for Hammer, a VTF file to act as the base texture, a Material Regenerator to do the down and dirty pixel changing, and a Material Proxy to link the regenerator to our texture.

The VMT file

Let's start by defining our VMT file. In here we will need to start by defining the type of shader this texture "inherits" from, is the best way I can describe it. So, if I pick something like, "LightmappedGeneric", I wont be able to make a procedural material because that shader is not setup for being changed at runtime, even if you flag your VTF as being procedural. You will just end up with a black image :). So, for our purposes I would choose something like, "UnlitGeneric". Another option is "MonitorScreen". Because these shaders do not limit me to having a static material.

The next step is to choose a basetexture. More than anything this texture is there for purposes of having a canvas to paint on. You can always change it at runtime to increase its size...but I'm going to try and keep this as simple as possible. So for now, just come up with a name for your texture, we will actually create it in the next step.

After choosing a base texture, we need to come up with our proxy name. We will define it later, but for now just come up with something creative. PixelRenderer, excellent choice. Now your VMT file should look something like this.

"UnlitGeneric"
{
	"$basetexture" "nicks_materials/prodscreen"
	"$translucent" 1
	
	"Proxies"
	{
		"PixelRenderer"
		{
		}
	}
}

The VTF file

I'm going to recommend you use VTFEdit for this, because it's a great program. Start off by opening up your Paint program of choice. I'm not rich so I'll stick with MS Paint. Go ahead and make it 512x512, it doesn't need to be anything special...a red background with the words "Procedural Screen" work wonderfully. Now, in VTFEdit, you will need to import your newly created texture.

Here is what mine looks like.

So, after you are finished importing we need to set some flags. These flags tell us an abundance of information about the image.

No Compression

This one is chosen for us because, we chose a non-compressed format for our image.

No Mipmap

Mip maps create problems when dealing with the LOD system and a dynamic image. If we change the pixels in the image, the mip maps would need to be regenerated, and if you don't you will end up with random memory spew obfuscating parts of our beautiful procedural image.

No Level of Detail

We don't want our image futzed the further away we get.

Procedural

This one tells source that our base texture can change at runtime, without it everything else means nothing.

So in VTFEdit, it looks something like this:

The material regenerator

Now, comes the part you've all been waiting for...and probably skipped right down to. So lets get to it. This is the brains of the operation, the meat of the can, the...you get the idea. Start out by defining our class. It will need to inherit from ITextureRegenerator, because that's the regenerator interface. There are 2 methods that we will need to overwrite for this to work. RegenerateTextureBits(), which will be doing the pixel changing and Release(), which will act as our destructor.

class CProceduralRegenerator : public ITextureRegenerator
{
public:
	CProceduralRegenerator( void ) {};
	virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect );
	virtual void Release( void );
};

Now we need to regenerate our texture bits.

void CProceduralRegenerator::RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect )
{
	CPixelWriter pixelWriter;
	pixelWriter.SetPixelMemory( pVTFTexture->Format(), 
		pVTFTexture->ImageData( 0, 0, 0 ), pVTFTexture->RowSizeInBytes( 0 ) );

	// Now upload the part we've been asked for
	int xmax = pSubRect->x + pSubRect->width;
	int ymax = pSubRect->y + pSubRect->height;
	int x, y;

	for( y = pSubRect->y; y < ymax; ++y )
	{
		pixelWriter.Seek( pSubRect->x, y );

		for( x=pSubRect->x; x < xmax; ++x )
		{
			pixelWriter.WritePixel( y%256, 0, 0, 255 );
		}
	}
}

Also define your Release() method, and delete anything you create.

void CProceduralRegenerator::Release()
{
	//delete stuff
}

The material proxy

Here we will connect our regenerator to our texture. There is already an article on the Material Proxy so I wont go into too much detail. But start out by defining your material proxy class. It should look something like this:

class CProceduralProxy: public IMaterialProxy
{
public:
	CProceduralProxy();
	virtual ~CProceduralProxy();
	virtual bool Init( IMaterial* pMaterial, KeyValues *pKeyValues );
	virtual void OnBind( void *pC_BaseEntity );
	virtual void Release( void ) { delete this; }

private:
	IMaterialVar		*m_pTextureVar;   // The material variable
	ITexture		*m_pTexture;      // The texture
	ITextureRegenerator	*m_pTextureRegen; // The regenerator
};

Here's a basic constructor to just set all our pointers to NULL.

CProceduralProxy::CProceduralProxy()
{
	m_pTextureVar = NULL;
	m_pTexture = NULL;
	m_pTextureRegen = NULL;
}

Our destructor will be called when release is called note the { delete this; } inside the class definition of the method Release(). Here we will disconnect our regenerator from the texture.

CProceduralProxy::~CProceduralProxy()
{
	if (m_pTexture != NULL)
	{
		m_pTexture->SetTextureRegenerator( NULL );
	}
}

The Init method is used to initialize everything during the precache period of loading.

bool CProceduralProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
	bool found;
	
	m_pTextureVar = pMaterial->FindVar("$basetexture", &found, false);  // Get a reference to our base texture variable
	if( !found )
	{
		m_pTextureVar = NULL;
		return false;
	}

	m_pTexture = m_pTextureVar->GetTextureValue();  // Now grab a ref to the actual texture
	if (m_pTexture != NULL)
	{
		m_pTextureRegen = new CProceduralRegenerator( );  // Here we create our regenerator
		m_pTexture->SetTextureRegenerator(m_pTextureRegen); // And here we attach it to the texture.
	}

	return true;
}

The OnBind() method is called for lots of reasons, read the Material Proxy article for more info. But think of this as our refresh method. We use this to tell the regenerator it needs to update the bits, which happens every time a new frame is rendered. The Download() method is how we tell the regenerator to redraw. You have the option of passing in a sub-rectangle of space you want to change, but all it does is send that info to your regenerator which you can use or ignore. If you don't give it a rectangle it sends a rectangle matching the full dimensions of our texture.

void CProceduralProxy::OnBind( void *pEntity )
{
	if( !m_pTexture )  // Make sure we have a texture
		return;

	if(!m_pTextureVar->IsTexture())  // Make sure it is a texture
		return;

	m_pTexture->Download(); // Force the regenerator to redraw
}

This exposes our proxy to the outside world and allows Source to match up the proxy class with the name listed as the proxy in the VMT file.

EXPOSE_INTERFACE( CProceduralProxy, IMaterialProxy, "PixelRenderer" IMATERIAL_PROXY_INTERFACE_VERSION );

Conclusion

This brings us full circle, and now our texture should bend to the will of our imagination on what to render at runtime. So now it's up to you to find a use for this feature. I'm currently working on an AVI renderer to be used in game, for various movie playing applications. You don't need to edit much of the code above to add this feature to your own games. For more information, you should checkout AVIKit, it has a very simple interface for doing just this. For more information about playing movies in Source, see AVI Materials.

Here is an example of Red vs. Blue: Episode 1 playing in HL2.

Before...

...and after.