Horde3D Wiki - User contributions [en]

Code Snippets

2010-08-10T15:05:42Z

Darkangel: /* More procedurally generated content code */

=What is this page?=
This page of the wiki is a sharing zone for rough Horde example code.

----

=== More procedurally generated content code ===
The following is similar but different to the [[Procedurally generated geometry tutorial]]
{{CppSourceCode|
description=Building a 2D grid of quads|
code=
<source lang="cpp" line="1">
void ScreenGridMesh( char*& data, int& fileSize, int& batchStart, int& batchCount, int& vertRStart, int& vertREnd )
{
extern int appWidth;
extern int appHeight;

//This example splits the screen up into groups of 16 pixels, and create a quad for each group.
int quadSize = 16;
int quadsH = (appWidth +quadSize-1) / quadSize;//divide by 16, rounding up
int quadsV = (appHeight+quadSize-1) / quadSize;
int quads = quadsH*quadsV;

int version = 5;//This is the current version of the GEO format (at the time of writing).

int numJoints = 0;//I don't have code below for writing joints...
int numMorphTargets = 0;//...or morph targets

//The lines that begin with //! or /*! could be used if you want a more complete vertex format (i.e. normal/binormal/tangent/joints/etc)
//! int numVertexStreams = 8;
int numVertexStreams = 2;//I'm just using position + tex-coord

int numVertices = quads * 4;// I'm making 4 verts per quad
int numTriangleIndices = quads * 6;//Each quad is 2 triangles. Each triangle is made up of 3 verts, so I need 6 indices to describe each quad.

//These are all "magic numbers" that horde uses to interpret the data streams
int vertPositionID = 0;
int vertNormalID = 1;
int vertTangentID = 2;
int vertBiTangentID = 3;
int vertJointIndexID = 4;
int vertJointWeightID = 5;
int vertTexCoordID = 6;
int vertTexCoord2ID = 7;
int positionElementSize = sizeof(float)*3;
int normalElementSize = sizeof(short)*3;
int tangentElementSize = sizeof(short)*3;
int biTangentElementSize= sizeof(short)*3;
int jointIndexElementSize = sizeof(char)*4;
int jointWeightElementSize = sizeof(char)*4;
int texCoordElementSize = sizeof(float)*2;
int texCoord2ElementSize = sizeof(float)*2;

batchStart = 0;
batchCount = numTriangleIndices;
vertRStart = 0;
vertREnd = numVertices-1;

//! int vertDataSize = positionElementSize+normalElementSize+
//! tangentElementSize+biTangentElementSize+
//! jointIndexElementSize+jointWeightElementSize+
//! texCoordElementSize+texCoord2ElementSize;
int vertDataSize = positionElementSize+texCoordElementSize;

int quadDataSize = vertDataSize*4 + sizeof(int)*6;
//! fileSize = sizeof(char)*4 + sizeof(int)*22 + quadDataSize*quads;
fileSize = sizeof(char)*4 + sizeof(int)*10 + quadDataSize*quads;

data = new char[fileSize];
int written = 0;

#define ASSERT( c ) \
if( !(c) ) { printf( "ASSERTION FAILED: %s\n", #c ); breakPlz(); }
#define WRITE_DATA( d, size ) \
memcpy( &data[written], d, size ); written += size; ASSERT( written <= fileSize );

//First write the header
WRITE_DATA( "H3DG", sizeof(char)*4 );
WRITE_DATA( &version, sizeof(int) );

//Joint data would go here, if I had any
WRITE_DATA( &numJoints, sizeof(int) );

//Then write the vertex-stream header
WRITE_DATA( &numVertexStreams, sizeof(int) );
WRITE_DATA( &numVertices, sizeof(int) );

//I'm making quads in this example, so all my loops are going to create 4 pieces of each data.

//To begin with I write the positions:
WRITE_DATA( &vertPositionID, sizeof(int) );
WRITE_DATA( &positionElementSize, sizeof(int) );
for( int y=0; y<quadsV; ++y )
{
for( int x=0; x<quadsH; ++x )
{
float positionA[3] = { ((x+0.0f)/(float)quadsH)*2.0f-1.0f, ((y+0.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionB[3] = { ((x+1.0f)/(float)quadsH)*2.0f-1.0f, ((y+0.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionC[3] = { ((x+1.0f)/(float)quadsH)*2.0f-1.0f, ((y+1.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionD[3] = { ((x+0.0f)/(float)quadsH)*2.0f-1.0f, ((y+1.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
WRITE_DATA( positionA, sizeof(float)*3 );
WRITE_DATA( positionB, sizeof(float)*3 );
WRITE_DATA( positionC, sizeof(float)*3 );
WRITE_DATA( positionD, sizeof(float)*3 );
}
}
/*!
//Normals/binormals/tangents should be floats in the 0-1 range, and then multiplied by 32767 and cast to 'short'. This is a form of compression.
WRITE_DATA( &vertNormalID, sizeof(int) );
WRITE_DATA( &normalElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 0, 0, 32767 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}
WRITE_DATA( &vertTangentID, sizeof(int) );
WRITE_DATA( &tangentElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 0, 32767, 0 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}
WRITE_DATA( &vertBiTangentID, sizeof(int) );
WRITE_DATA( &biTangentElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 32767, 0, 0 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}

//Each vertex can be influenced by 4 joints - the joint IDs are written here
WRITE_DATA( &vertJointIndexID, sizeof(int) );
WRITE_DATA( &jointIndexElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
char j[] = { 0, 0, 0, 0 };
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
}

//The 'percent' (out of 255, not out of 100) that each of the above joints influences the vertex:
WRITE_DATA( &vertJointWeightID, sizeof(int) );
WRITE_DATA( &jointWeightElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
ASSERT( sizeof(char) == 1 )
char j[] = { 255, 0, 0, 0 };
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
}
*/
//Tex-coords are pairs of floats
WRITE_DATA( &vertTexCoordID, sizeof(int) );
WRITE_DATA( &texCoordElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
float uvTl[] = { 0.0f, 1.0f };
float uvBl[] = { 0.0f, 0.0f };
float uvBr[] = { 1.0f, 0.0f };
float uvTr[] = { 1.0f, 1.0f };
WRITE_DATA( uvTl, sizeof(float)*2 );
WRITE_DATA( uvBl, sizeof(float)*2 );
WRITE_DATA( uvBr, sizeof(float)*2 );
WRITE_DATA( uvTr, sizeof(float)*2 );
}
/*!
//You can have a second set of tex-coords if you want
WRITE_DATA( &vertTexCoord2ID, sizeof(int) );
WRITE_DATA( &texCoord2ElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
float uvTl[] = { 0.0f, 1.0f };
float uvBl[] = { 0.0f, 0.0f };
float uvBr[] = { 1.0f, 0.0f };
float uvTr[] = { 1.0f, 1.0f };
WRITE_DATA( uvTl, sizeof(float)*2 );
WRITE_DATA( uvBl, sizeof(float)*2 );
WRITE_DATA( uvBr, sizeof(float)*2 );
WRITE_DATA( uvTr, sizeof(float)*2 );
}*/

//Finally, time for the index buffer
WRITE_DATA( &numTriangleIndices, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
int base = i * 4;
int a = base, b = base+1, c = base+2, d=base+2, e=base+3, f=base;
WRITE_DATA( &a, sizeof(int) );
WRITE_DATA( &b, sizeof(int) );
WRITE_DATA( &c, sizeof(int) );
WRITE_DATA( &d, sizeof(int) );
WRITE_DATA( &e, sizeof(int) );
WRITE_DATA( &f, sizeof(int) );
}

//Morph targets would go here, if I had any
WRITE_DATA( &numMorphTargets, sizeof(int) );

ASSERT( written == fileSize );//ensure we didn't over/under-use the buffer
}
</source>
}}
{{CppSourceCode|
description= Example Usage|
code=
<source lang="cpp" line="1">
// Build a geo
H3DRes gridGeo = h3dAddResource( H3DResTypes::Geometry, "runtime/blahBlah.geo", H3DResFlags::NoQuery );
int batchStart = 0, batchCount = 0, vertRStart = 0, vertREnd = 0;
{
int dataSize = 0;
char* data = 0;
ScreenGridMesh( data, dataSize, batchStart, batchCount, vertRStart, vertREnd );
bool loadedData = h3dLoadResource( gridGeo, data, dataSize );
delete [] lensBlurData;
}

// Load a material
H3DRes material = h3dAddResource( H3DResTypes::Material, "materials/grid.material.xml", 0 );
h3dutLoadResourcesFromDisk( _contentDir.c_str() );

// Create a model/mesh from the procedural geo
H3DNode model = h3dAddModelNode( H3DRootNode, "MyModel", gridGeo );
H3DNode mesh = h3dAddMeshNode( model, "MyMesh", material, batchStart, batchCount, vertRStart, vertREnd );
</source>
}}

Code Snippets

2010-08-10T15:02:41Z

Darkangel: /* More procedurally generated content code */

=What is this page?=
This page of the wiki is a sharing zone for rough Horde example code.

----

=== More procedurally generated content code ===
The following is similar but different to the [[Procedurally generated geometry tutorial]]
{{CppSourceCode|
description=Building a 2D grid of points|
code=
<source lang="cpp" line="1">
void ScreenGridMesh( char*& data, int& fileSize, int& batchStart, int& batchCount, int& vertRStart, int& vertREnd )
{
extern int appWidth;
extern int appHeight;

//This example splits the screen up into groups of 16 pixels, and create a quad for each group.
int quadSize = 16;
int quadsH = (appWidth +quadSize-1) / quadSize;//divide by 16, rounding up
int quadsV = (appHeight+quadSize-1) / quadSize;
int quads = quadsH*quadsV;

int version = 5;//This is the current version of the GEO format (at the time of writing).

int numJoints = 0;//I don't have code below for writing joints...
int numMorphTargets = 0;//...or morph targets

//The lines that begin with //! or /*! could be used if you want a more complete vertex format (i.e. normal/binormal/tangent/joints/etc)
//! int numVertexStreams = 8;
int numVertexStreams = 2;//I'm just using position + tex-coord

int numVertices = quads * 4;// I'm making 4 verts per quad
int numTriangleIndices = quads * 6;//Each quad is 2 triangles. Each triangle is made up of 3 verts, so I need 6 indices to describe each quad.

//These are all "magic numbers" that horde uses to interpret the data streams
int vertPositionID = 0;
int vertNormalID = 1;
int vertTangentID = 2;
int vertBiTangentID = 3;
int vertJointIndexID = 4;
int vertJointWeightID = 5;
int vertTexCoordID = 6;
int vertTexCoord2ID = 7;
int positionElementSize = sizeof(float)*3;
int normalElementSize = sizeof(short)*3;
int tangentElementSize = sizeof(short)*3;
int biTangentElementSize= sizeof(short)*3;
int jointIndexElementSize = sizeof(char)*4;
int jointWeightElementSize = sizeof(char)*4;
int texCoordElementSize = sizeof(float)*2;
int texCoord2ElementSize = sizeof(float)*2;

batchStart = 0;
batchCount = numTriangleIndices;
vertRStart = 0;
vertREnd = numVertices-1;

//! int vertDataSize = positionElementSize+normalElementSize+
//! tangentElementSize+biTangentElementSize+
//! jointIndexElementSize+jointWeightElementSize+
//! texCoordElementSize+texCoord2ElementSize;
int vertDataSize = positionElementSize+texCoordElementSize;

int quadDataSize = vertDataSize*4 + sizeof(int)*6;
//! fileSize = sizeof(char)*4 + sizeof(int)*22 + quadDataSize*quads;
fileSize = sizeof(char)*4 + sizeof(int)*10 + quadDataSize*quads;

data = new char[fileSize];
int written = 0;

#define ASSERT( c ) \
if( !(c) ) { printf( "ASSERTION FAILED: %s\n", #c ); breakPlz(); }
#define WRITE_DATA( d, size ) \
memcpy( &data[written], d, size ); written += size; ASSERT( written <= fileSize );

//First write the header
WRITE_DATA( "H3DG", sizeof(char)*4 );
WRITE_DATA( &version, sizeof(int) );

//Joint data would go here, if I had any
WRITE_DATA( &numJoints, sizeof(int) );

//Then write the vertex-stream header
WRITE_DATA( &numVertexStreams, sizeof(int) );
WRITE_DATA( &numVertices, sizeof(int) );

//I'm making quads in this example, so all my loops are going to create 4 pieces of each data.

//To begin with I write the positions:
WRITE_DATA( &vertPositionID, sizeof(int) );
WRITE_DATA( &positionElementSize, sizeof(int) );
for( int y=0; y<quadsV; ++y )
{
for( int x=0; x<quadsH; ++x )
{
float positionA[3] = { ((x+0.0f)/(float)quadsH)*2.0f-1.0f, ((y+0.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionB[3] = { ((x+1.0f)/(float)quadsH)*2.0f-1.0f, ((y+0.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionC[3] = { ((x+1.0f)/(float)quadsH)*2.0f-1.0f, ((y+1.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionD[3] = { ((x+0.0f)/(float)quadsH)*2.0f-1.0f, ((y+1.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
WRITE_DATA( positionA, sizeof(float)*3 );
WRITE_DATA( positionB, sizeof(float)*3 );
WRITE_DATA( positionC, sizeof(float)*3 );
WRITE_DATA( positionD, sizeof(float)*3 );
}
}
/*!
//Normals/binormals/tangents should be floats in the 0-1 range, and then multiplied by 32767 and cast to 'short'. This is a form of compression.
WRITE_DATA( &vertNormalID, sizeof(int) );
WRITE_DATA( &normalElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 0, 0, 32767 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}
WRITE_DATA( &vertTangentID, sizeof(int) );
WRITE_DATA( &tangentElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 0, 32767, 0 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}
WRITE_DATA( &vertBiTangentID, sizeof(int) );
WRITE_DATA( &biTangentElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 32767, 0, 0 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}

//Each vertex can be influenced by 4 joints - the joint IDs are written here
WRITE_DATA( &vertJointIndexID, sizeof(int) );
WRITE_DATA( &jointIndexElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
char j[] = { 0, 0, 0, 0 };
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
}

//The 'percent' (out of 255, not out of 100) that each of the above joints influences the vertex:
WRITE_DATA( &vertJointWeightID, sizeof(int) );
WRITE_DATA( &jointWeightElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
ASSERT( sizeof(char) == 1 )
char j[] = { 255, 0, 0, 0 };
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
}
*/
//Tex-coords are pairs of floats
WRITE_DATA( &vertTexCoordID, sizeof(int) );
WRITE_DATA( &texCoordElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
float uvTl[] = { 0.0f, 1.0f };
float uvBl[] = { 0.0f, 0.0f };
float uvBr[] = { 1.0f, 0.0f };
float uvTr[] = { 1.0f, 1.0f };
WRITE_DATA( uvTl, sizeof(float)*2 );
WRITE_DATA( uvBl, sizeof(float)*2 );
WRITE_DATA( uvBr, sizeof(float)*2 );
WRITE_DATA( uvTr, sizeof(float)*2 );
}
/*!
//You can have a second set of tex-coords if you want
WRITE_DATA( &vertTexCoord2ID, sizeof(int) );
WRITE_DATA( &texCoord2ElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
float uvTl[] = { 0.0f, 1.0f };
float uvBl[] = { 0.0f, 0.0f };
float uvBr[] = { 1.0f, 0.0f };
float uvTr[] = { 1.0f, 1.0f };
WRITE_DATA( uvTl, sizeof(float)*2 );
WRITE_DATA( uvBl, sizeof(float)*2 );
WRITE_DATA( uvBr, sizeof(float)*2 );
WRITE_DATA( uvTr, sizeof(float)*2 );
}*/

//Finally, time for the index buffer
WRITE_DATA( &numTriangleIndices, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
int base = i * 4;
int a = base, b = base+1, c = base+2, d=base+2, e=base+3, f=base;
WRITE_DATA( &a, sizeof(int) );
WRITE_DATA( &b, sizeof(int) );
WRITE_DATA( &c, sizeof(int) );
WRITE_DATA( &d, sizeof(int) );
WRITE_DATA( &e, sizeof(int) );
WRITE_DATA( &f, sizeof(int) );
}

//Morph targets would go here, if I had any
WRITE_DATA( &numMorphTargets, sizeof(int) );

ASSERT( written == fileSize );//ensure we didn't over/under-use the buffer
}
</source>
}}
{{CppSourceCode|
description= Example Usage|
code=
<source lang="cpp" line="1">
// Build a geo
H3DRes gridGeo = h3dAddResource( H3DResTypes::Geometry, "runtime/blahBlah.geo", H3DResFlags::NoQuery );
int batchStart = 0, batchCount = 0, vertRStart = 0, vertREnd = 0;
{
int dataSize = 0;
char* data = 0;
BuildLensBlurMesh( data, dataSize, batchStart, batchCount, vertRStart, vertREnd );
bool loadedData = h3dLoadResource( gridGeo, data, dataSize );
delete [] lensBlurData;
}

// Load a material
H3DRes material = h3dAddResource( H3DResTypes::Material, "materials/grid.material.xml", 0 );
h3dutLoadResourcesFromDisk( _contentDir.c_str() );

// Create a model/mesh from the procedural geo
H3DNode model = h3dAddModelNode( H3DRootNode, "MyModel", gridGeo );
H3DNode mesh = h3dAddMeshNode( model, "MyMesh", material, batchStart, batchCount, vertRStart, vertREnd );
</source>
}}

Code Snippets

2010-08-10T15:00:08Z

Darkangel: /* More procedurally generated content code */

=What is this page?=
This page of the wiki is a sharing zone for rough Horde example code.

----

=== More procedurally generated content code ===
The following is similar but different to the [[Procedurally generated geometry tutorial]]
{{CppSourceCode|
description=Building a 2D grid of points|
code=
<source lang="cpp" line="1">
void ScreenGridMesh( char*& data, int& fileSize, int& batchStart, int& batchCount, int& vertRStart, int& vertREnd )
{
extern int appWidth;
extern int appHeight;

//This example splits the screen up into groups of 16 pixels, and create a quad for each group.
int quadSize = 16;
int quadSizeHalf = quadSize/2;
int quadsH = (appWidth +quadSize-1) / quadSize;//divide by 16, rounding up
int quadsV = (appHeight+quadSize-1) / quadSize;
int quads = quadsH*quadsV;

int version = 5;
int numJoints = 0;//I don't have code below for writing joints...
int numMorphTargets = 0;//...or morph targets

//The lines that begin with //! or /*! could be used if you want a more complete vertex format (i.e. normal/binormal/tangent/joints/etc)
//! int numVertexStreams = 8;
int numVertexStreams = 2;//I'm just using position + tex-coord

int numVertices = quads * 4;// I'm making 4 verts per quad
int numTriangleIndices = quads * 6;//Each quad is 2 triangles. Each triangle is made up of 3 verts, so I need 6 indices to describe each quad.

int vertPositionID = 0;
int vertNormalID = 1;
int vertTangentID = 2;
int vertBiTangentID = 3;
int vertJointIndexID = 4;
int vertJointWeightID = 5;
int vertTexCoordID = 6;
int vertTexCoord2ID = 7;
int positionElementSize = sizeof(float)*3;
int normalElementSize = sizeof(short)*3;
int tangentElementSize = sizeof(short)*3;
int biTangentElementSize= sizeof(short)*3;
int jointIndexElementSize = sizeof(char)*4;
int jointWeightElementSize = sizeof(char)*4;
int texCoordElementSize = sizeof(float)*2;
int texCoord2ElementSize = sizeof(float)*2;

batchStart = 0;
batchCount = numTriangleIndices;
vertRStart = 0;
vertREnd = numVertices-1;

//! int vertDataSize = positionElementSize+normalElementSize+
tangentElementSize+biTangentElementSize+
jointIndexElementSize+jointWeightElementSize+
texCoordElementSize+texCoord2ElementSize;
int vertDataSize = positionElementSize+texCoordElementSize;

int quadDataSize = vertDataSize*4 + sizeof(int)*6;
//! fileSize = sizeof(char)*4 + sizeof(int)*22 + quadDataSize*quads;
fileSize = sizeof(char)*4 + sizeof(int)*10 + quadDataSize*quads;

data = new char[fileSize];
int written = 0;

#define ASSERT( c ) \
if( !(c) ) { printf( "ASSERTION FAILED: %s\n", #c ); breakPlz(); }
#define WRITE_DATA( d, size ) \
memcpy( &data[written], d, size ); written += size; ASSERT( written <= fileSize );

//First write the header
WRITE_DATA( "H3DG", sizeof(char)*4 );
WRITE_DATA( &version, sizeof(int) );

//Joint data would go here, if I had any
WRITE_DATA( &numJoints, sizeof(int) );

//Then write the vertex-stream header
WRITE_DATA( &numVertexStreams, sizeof(int) );
WRITE_DATA( &numVertices, sizeof(int) );

//I'm making quads in this example, so all my loops are going to create 4 pieces of each data.

//To begin with I write the positions:
WRITE_DATA( &vertPositionID, sizeof(int) );
WRITE_DATA( &positionElementSize, sizeof(int) );
for( int y=0; y<quadsV; ++y )
{
for( int x=0; x<quadsH; ++x )
{
float positionA[3] = { ((x+0.0f)/(float)quadsH)*2.0f-1.0f, ((y+0.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionB[3] = { ((x+1.0f)/(float)quadsH)*2.0f-1.0f, ((y+0.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionC[3] = { ((x+1.0f)/(float)quadsH)*2.0f-1.0f, ((y+1.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionD[3] = { ((x+0.0f)/(float)quadsH)*2.0f-1.0f, ((y+1.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
WRITE_DATA( positionA, sizeof(float)*3 );
WRITE_DATA( positionB, sizeof(float)*3 );
WRITE_DATA( positionC, sizeof(float)*3 );
WRITE_DATA( positionD, sizeof(float)*3 );
}
}
/*!
//Normals/binormals/tangents should be floats in the 0-1 range, and then multiplied by 32767 and cast to 'short'. This is a form of compression.
WRITE_DATA( &vertNormalID, sizeof(int) );
WRITE_DATA( &normalElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 0, 0, 32767 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}
WRITE_DATA( &vertTangentID, sizeof(int) );
WRITE_DATA( &tangentElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 0, 32767, 0 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}
WRITE_DATA( &vertBiTangentID, sizeof(int) );
WRITE_DATA( &biTangentElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 32767, 0, 0 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}

//Each vertex can be influenced by 4 joints - the joint IDs are written here
WRITE_DATA( &vertJointIndexID, sizeof(int) );
WRITE_DATA( &jointIndexElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
char j[] = { 0, 0, 0, 0 };
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
}

//The 'percent' (out of 255, not out of 100) that each of the above joints influences the vertex:
WRITE_DATA( &vertJointWeightID, sizeof(int) );
WRITE_DATA( &jointWeightElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
ASSERT( sizeof(char) == 1 )
char j[] = { 255, 0, 0, 0 };
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
}
*/
//Tex-coords are pairs of floats
WRITE_DATA( &vertTexCoordID, sizeof(int) );
WRITE_DATA( &texCoordElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
float uvTl[] = { 0.0f, 1.0f };
float uvBl[] = { 0.0f, 0.0f };
float uvBr[] = { 1.0f, 0.0f };
float uvTr[] = { 1.0f, 1.0f };
WRITE_DATA( uvTl, sizeof(float)*2 );
WRITE_DATA( uvBl, sizeof(float)*2 );
WRITE_DATA( uvBr, sizeof(float)*2 );
WRITE_DATA( uvTr, sizeof(float)*2 );
}
/*!
//You can have a second set of tex-coords if you want
WRITE_DATA( &vertTexCoord2ID, sizeof(int) );
WRITE_DATA( &texCoord2ElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
float uvTl[] = { 0.0f, 1.0f };
float uvBl[] = { 0.0f, 0.0f };
float uvBr[] = { 1.0f, 0.0f };
float uvTr[] = { 1.0f, 1.0f };
WRITE_DATA( uvTl, sizeof(float)*2 );
WRITE_DATA( uvBl, sizeof(float)*2 );
WRITE_DATA( uvBr, sizeof(float)*2 );
WRITE_DATA( uvTr, sizeof(float)*2 );
}*/

//Finally, time for the index buffer
WRITE_DATA( &numTriangleIndices, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
int base = i * 4;
int a = base, b = base+1, c = base+2, d=base+2, e=base+3, f=base;
WRITE_DATA( &a, sizeof(int) );
WRITE_DATA( &b, sizeof(int) );
WRITE_DATA( &c, sizeof(int) );
WRITE_DATA( &d, sizeof(int) );
WRITE_DATA( &e, sizeof(int) );
WRITE_DATA( &f, sizeof(int) );
}

//Morph targets would go here, if I had any
WRITE_DATA( &numMorphTargets, sizeof(int) );

ASSERT( written == fileSize );//ensure we didn't over/under-use the buffer
}
</source>
}}
{{CppSourceCode|
description= Example Usage|
code=
<source lang="cpp" line="1">
// Build a geo
H3DRes gridGeo = h3dAddResource( H3DResTypes::Geometry, "runtime/blahBlah.geo", H3DResFlags::NoQuery );
int batchStart = 0, batchCount = 0, vertRStart = 0, vertREnd = 0;
{
int dataSize = 0;
char* data = 0;
BuildLensBlurMesh( data, dataSize, batchStart, batchCount, vertRStart, vertREnd );
bool loadedData = h3dLoadResource( gridGeo, data, dataSize );
delete [] lensBlurData;
}

// Load a material
H3DRes material = h3dAddResource( H3DResTypes::Material, "materials/grid.material.xml", 0 );
h3dutLoadResourcesFromDisk( _contentDir.c_str() );

// Create a model/mesh from the procedural geo
H3DNode model = h3dAddModelNode( H3DRootNode, "MyModel", gridGeo );
H3DNode mesh = h3dAddMeshNode( model, "MyMesh", material, batchStart, batchCount, vertRStart, vertREnd );
</source>
}}

Code Snippets

2010-08-10T14:53:14Z

Darkangel: Snippets!

=What is this page?=
This page of the wiki is a sharing zone for rough Horde example code.

----

=== More procedurally generated content code ===
The following is similar but different to the [[Procedurally generated geometry tutorial]]
{{CppSourceCode|
description=Building a 2D grid of points|
code=
<source lang="cpp" line="1">
void ScreenGridMesh( char*& data, int& fileSize, int& batchStart, int& batchCount, int& vertRStart, int& vertREnd )
{
extern int appWidth;
extern int appHeight;

//This example splits the screen up into groups of 16 pixels, and create a quad for each group.
int quadSize = 16;
int quadSizeHalf = quadSize/2;
int quadsH = (appWidth +quadSize-1) / quadSize;//divide by 16, rounding up
int quadsV = (appHeight+quadSize-1) / quadSize;
int quads = quadsH*quadsV;

int version = 5;
int numJoints = 0;//I don't have code below for writing joints

//The lines that begin with //! or /*! could be used if you want a more complete vertex format (i.e. normal/binormal/tangent/joints/etc)
//! int numVertexStreams = 8;
int numVertexStreams = 2;
int numVertices = quads * 4;
int vertPositionID = 0;
int vertNormalID = 1;
int vertTangentID = 2;
int vertBiTangentID = 3;
int vertJointIndexID = 4;
int vertJointWeightID = 5;
int vertTexCoordID = 6;
int vertTexCoord2ID = 7;
int positionElementSize = sizeof(float)*3;
int normalElementSize = sizeof(short)*3;
int tangentElementSize = sizeof(short)*3;
int biTangentElementSize= sizeof(short)*3;
int jointIndexElementSize = sizeof(char)*4;
int jointWeightElementSize = sizeof(char)*4;
int texCoordElementSize = sizeof(float)*2;
int texCoord2ElementSize = sizeof(float)*2;
int numTriangleIndices = quads * 6;
int numMorphTargets = 0;

batchStart = 0;
batchCount = numTriangleIndices;
vertRStart = 0;
vertREnd = numVertices-1;

//! int vertDataSize = positionElementSize+normalElementSize+tangentElementSize+biTangentElementSize+jointIndexElementSize+jointWeightElementSize+texCoordElementSize+texCoord2ElementSize;
int vertDataSize = positionElementSize+texCoordElementSize;

int quadDataSize = vertDataSize*4 + sizeof(int)*6;
//! fileSize = sizeof(char)*4 + sizeof(int)*22 + quadDataSize*quads;
fileSize = sizeof(char)*4 + sizeof(int)*10 + quadDataSize*quads;

data = new char[fileSize];
int written = 0;

#define ASSERT( c ) \
if( !(c) ) { printf( "ASSERTION FAILED: %s\n", #c ); breakPlz(); }
#define WRITE_DATA( d, size ) \
memcpy( &data[written], d, size ); written += size; ASSERT( written <= fileSize );

WRITE_DATA( "H3DG", sizeof(char)*4 );
WRITE_DATA( &version, sizeof(int) );
WRITE_DATA( &numJoints, sizeof(int) );
WRITE_DATA( &numVertexStreams, sizeof(int) );
WRITE_DATA( &numVertices, sizeof(int) );

//I'm making quads in this example, so all my loops are going to create 4 pieces of each data.

//To begin with I write the positions:
WRITE_DATA( &vertPositionID, sizeof(int) );
WRITE_DATA( &positionElementSize, sizeof(int) );
for( int y=0; y<quadsV; ++y )
{
for( int x=0; x<quadsH; ++x )
{
float positionA[3] = { ((x+0.0f)/(float)quadsH)*2.0f-1.0f, ((y+0.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionB[3] = { ((x+1.0f)/(float)quadsH)*2.0f-1.0f, ((y+0.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionC[3] = { ((x+1.0f)/(float)quadsH)*2.0f-1.0f, ((y+1.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
float positionD[3] = { ((x+0.0f)/(float)quadsH)*2.0f-1.0f, ((y+1.0f)/(float)quadsV)*2.0f-1.0f, 0.0f };
WRITE_DATA( positionA, sizeof(float)*3 );
WRITE_DATA( positionB, sizeof(float)*3 );
WRITE_DATA( positionC, sizeof(float)*3 );
WRITE_DATA( positionD, sizeof(float)*3 );
}
}
/*!
//Normals/binormals/tangents should be floats in the 0-1 range, and then multiplied by 32767 and cast to 'short'. This is a form of compression.
WRITE_DATA( &vertNormalID, sizeof(int) );
WRITE_DATA( &normalElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 0, 0, 32767 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}
WRITE_DATA( &vertTangentID, sizeof(int) );
WRITE_DATA( &tangentElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 0, 32767, 0 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}
WRITE_DATA( &vertBiTangentID, sizeof(int) );
WRITE_DATA( &biTangentElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
short n[] = { 32767, 0, 0 };
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
WRITE_DATA( n, sizeof(short)*3 );
}

//Each vertex can be influenced by 4 joints - the joint IDs are written here
WRITE_DATA( &vertJointIndexID, sizeof(int) );
WRITE_DATA( &jointIndexElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
char j[] = { 0, 0, 0, 0 };
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
}

//The 'percent' (out of 255, not out of 100) that each of the above joints influences the vertex:
WRITE_DATA( &vertJointWeightID, sizeof(int) );
WRITE_DATA( &jointWeightElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
ASSERT( sizeof(char) == 1 )
char j[] = { 255, 0, 0, 0 };
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
WRITE_DATA( j, sizeof(char)*4 );
}
*/
//Tex-coords are pairs of floats
WRITE_DATA( &vertTexCoordID, sizeof(int) );
WRITE_DATA( &texCoordElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
float uvTl[] = { 0.0f, 1.0f };
float uvBl[] = { 0.0f, 0.0f };
float uvBr[] = { 1.0f, 0.0f };
float uvTr[] = { 1.0f, 1.0f };
WRITE_DATA( uvTl, sizeof(float)*2 );
WRITE_DATA( uvBl, sizeof(float)*2 );
WRITE_DATA( uvBr, sizeof(float)*2 );
WRITE_DATA( uvTr, sizeof(float)*2 );
}
/*!
//You can have a second set of tex-coords if you want
WRITE_DATA( &vertTexCoord2ID, sizeof(int) );
WRITE_DATA( &texCoord2ElementSize, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
float uvTl[] = { 0.0f, 1.0f };
float uvBl[] = { 0.0f, 0.0f };
float uvBr[] = { 1.0f, 0.0f };
float uvTr[] = { 1.0f, 1.0f };
WRITE_DATA( uvTl, sizeof(float)*2 );
WRITE_DATA( uvBl, sizeof(float)*2 );
WRITE_DATA( uvBr, sizeof(float)*2 );
WRITE_DATA( uvTr, sizeof(float)*2 );
}*/

//Finally, time for the index buffer
WRITE_DATA( &numTriangleIndices, sizeof(int) );
for( int i=0; i!=quads; ++i )
{
int base = i * 4;
int a = base, b = base+1, c = base+2, d=base+2, e=base+3, f=base;
WRITE_DATA( &a, sizeof(int) );
WRITE_DATA( &b, sizeof(int) );
WRITE_DATA( &c, sizeof(int) );
WRITE_DATA( &d, sizeof(int) );
WRITE_DATA( &e, sizeof(int) );
WRITE_DATA( &f, sizeof(int) );
}

//Morph targets would go here, if I had any
WRITE_DATA( &numMorphTargets, sizeof(int) );

ASSERT( written == fileSize );//ensure we didn't over/under-use the buffer
}
</source>
}}
{{CppSourceCode|
description= Example Usage|
code=
<source lang="cpp" line="1">
// Build a geo
H3DRes gridGeo = h3dAddResource( H3DResTypes::Geometry, "runtime/blahBlah.geo", H3DResFlags::NoQuery );
int batchStart = 0, batchCount = 0, vertRStart = 0, vertREnd = 0;
{
int dataSize = 0;
char* data = 0;
BuildLensBlurMesh( data, dataSize, batchStart, batchCount, vertRStart, vertREnd );
bool loadedData = h3dLoadResource( gridGeo, data, dataSize );
delete [] lensBlurData;
}

// Load a material
H3DRes material = h3dAddResource( H3DResTypes::Material, "materials/grid.material.xml", 0 );
h3dutLoadResourcesFromDisk( _contentDir.c_str() );

// Create a model/mesh from the procedural geo
H3DNode model = h3dAddModelNode( H3DRootNode, "MyModel", gridGeo );
H3DNode mesh = h3dAddMeshNode( model, "MyMesh", material, batchStart, batchCount, vertRStart, vertREnd );
</source>
}}

Shading Technique - Glow Mapping

2008-08-08T00:15:11Z

Darkangel: fixed a typo

{| border="0"
| {{ContentBlock|width=800|color=white
|content={{!!}}

'''I'm in the process of writing this article - come back later!'''

== Overview ==
For an in-depth overview of this technique, see the Gamasutra article [http://www.gamasutra.com/features/20040526/james_pfv.htm Real-Time Glow] by By Greg James and John O’Rorke.

== Temporary code dump ==
Until I finish writing this article, here's the undocumented code ;)

'''Pipeline changes'''

{{CppSourceCode|
description= Setup the RenderTargets. If this is for HDR, then these RenderTargets will already exist, so just change depthBuf to "true" on the first one|
code=
<source lang="cpp" line="1">
<Setup>
<RenderTarget id="BLURBUF1" depthBuf="true" numColBufs="1" format="RGBA8" bilinear="true" scale="0.25" />
<RenderTarget id="BLURBUF2" depthBuf="false" numColBufs="1" format="RGBA8" bilinear="true" scale="0.25" />
</Setup>
</source>}}

{{CppSourceCode|
description= insert this new stage after the "Geometry" stage.|
code=
<source lang="cpp" line="1">
<stage id="Glow">
<SwitchTarget target="BLURBUF1" />
<ClearTarget depthBuf="true" colBuf0="true" />
<DrawGeometry context="GLOWMASK" />


<SwitchTarget target="BLURBUF2" />
<BindBuffer texUnit="0" target="BLURBUF1" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURV" />
<SwitchTarget target="BLURBUF1" />
<BindBuffer texUnit="0" target="BLURBUF2" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURH" />

<SwitchTarget target="BLURBUF2" />
<BindBuffer texUnit="0" target="BLURBUF1" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURV" />
<SwitchTarget target="BLURBUF1" />
<BindBuffer texUnit="0" target="BLURBUF2" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURH" />

<SwitchTarget target="BLURBUF2" />
<BindBuffer texUnit="0" target="BLURBUF1" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURV" />
<SwitchTarget target="BLURBUF1" />
<BindBuffer texUnit="0" target="BLURBUF2" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURH" />


<SwitchTarget target="" />
<BindBuffer texUnit="0" target="BLURBUF1" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="FINALPASS" />
</stage>
</source>}}

'''New shader code'''

{{CppSourceCode|
description= This context is designed to be added to a copy of the parallax shader - parallax_glow.shader.xml|
code=
<source lang="cpp" line="1">
<Context id="GLOWMASK">

<VertexShader>
<InsCode code="utilityLib/vertCommon.glsl" />
<DefCode>
<![CDATA[
uniform vec3 viewer;
attribute vec2 texCoords0;
attribute vec3 normal, tangent, bitangent;
varying vec3 eyeTS;
varying vec2 texCoords;
varying vec4 pos;

void main( void )
{
// Transform tangent space basis
vec3 tsbTangent = normalize( calcWorldVec( tangent ) );
vec3 tsbBitangent = normalize( calcWorldVec( bitangent ) );
vec3 tsbNormal = normalize( calcWorldVec( normal ) );

// Calculate world space position
pos = calcWorldPos( gl_Vertex );

// Eye vector and eye vector in tangent space
eyeTS = calcTanVec( viewer - pos.xyz, tsbTangent, tsbBitangent, tsbNormal );

// Calculate texture coordinates and clip space position
texCoords = texCoords0;
gl_Position = gl_ModelViewProjectionMatrix * pos;
}
]]>
</DefCode>
</VertexShader>

<FragmentShader>
<DefCode>
<![CDATA[
uniform sampler2D tex0;
varying vec3 eyeTS;
varying vec2 texCoords;

void main( void )
{
const float plxScale = 0.03;
const float plxBias = -0.015;

// Iterative parallax mapping
vec3 newCoords = vec3( texCoords, 0 );
vec3 eye = normalize( eyeTS );
for( int i = 0; i < 4; ++i )
{
vec4 nmap = texture2D( tex0, texCoords.st );
float height = nmap.a * plxScale + plxBias;
newCoords += (height - newCoords.p) * nmap.z * eye;
}

vec4 glow = texture2D( tex0, newCoords.st ).rgba;
glow *= glow.a;

gl_FragColor = glow;
}
]]>
</DefCode>
</FragmentShader>
</Context>
</source>}}

{{CppSourceCode|
description= This is a new shader, called postGlow.shader.xml|
code=
<source lang="cpp" line="1">
<Shader>

<Context id="BLURH">
<RenderConfig writeDepth="false" />
<VertexShader>
<DefCode>
<![CDATA[
varying vec2 texCoord;
void main( void )
{
texCoord = gl_MultiTexCoord0.st;
gl_Position = gl_ProjectionMatrix * gl_Vertex;
}
]]>
</DefCode>
</VertexShader>
<FragmentShader>
<InsCode code="utilityLib/fragPostProcess.glsl" />
<DefCode>
<![CDATA[
uniform sampler2D tex;
uniform vec2 frameBufSize;
varying vec2 texCoord;
void main( void )
{
float halfPixel = 0.5 / frameBufSize.x;
vec4 col = texture2D( tex, texCoord + vec2( halfPixel, 0.0 ) );
col += texture2D( tex, texCoord - vec2( halfPixel, 0.0 ) );
col += texture2D( tex, texCoord + vec2( halfPixel*3.0, 0.0 ) );
col += texture2D( tex, texCoord - vec2( halfPixel*3.0, 0.0 ) );
gl_FragColor = col * 0.25;
}
]]>
</DefCode>
</FragmentShader>
</Context>
<Context id="BLURV">
<RenderConfig writeDepth="false" />
<VertexShader>
<DefCode>
<![CDATA[
varying vec2 texCoord;
void main( void )
{
texCoord = gl_MultiTexCoord0.st;
gl_Position = gl_ProjectionMatrix * gl_Vertex;
}
]]>
</DefCode>
</VertexShader>
<FragmentShader>
<InsCode code="utilityLib/fragPostProcess.glsl" />
<DefCode>
<![CDATA[
uniform sampler2D tex;
uniform vec2 frameBufSize;
varying vec2 texCoord;
void main( void )
{
float halfPixel = 0.5 / frameBufSize.y;
vec4 col = texture2D( tex, texCoord + vec2( 0.0, halfPixel ) );
col += texture2D( tex, texCoord - vec2( 0.0, halfPixel ) );
col += texture2D( tex, texCoord + vec2( 0.0, halfPixel*3.0 ) );
col += texture2D( tex, texCoord - vec2( 0.0, halfPixel*3.0 ) );
gl_FragColor = col * 0.25;
}
]]>
</DefCode>
</FragmentShader>
</Context>

<Context id="FINALPASS">
<RenderConfig writeDepth="false" blendMode="ADD" />

<VertexShader>
<DefCode>
<![CDATA[
varying vec2 texCoord;

void main( void )
{
texCoord = gl_MultiTexCoord0.st;
gl_Position = gl_ProjectionMatrix * gl_Vertex;
}
]]>
</DefCode>
</VertexShader>

<FragmentShader>
<DefCode>
<![CDATA[
uniform sampler2D tex0, tex1;
uniform vec2 frameBufSize;
uniform vec4 hdrParams;
varying vec2 texCoord;

void main( void )
{
gl_FragColor = texture2D( tex0, texCoord ); // Glow color
}
]]>
</DefCode>
</FragmentShader>
</Context>
</Shader>
</source>}}

{{CppSourceCode|
description= The material to go with the postGlow shader - postGlow.material.xml|
code=
<source lang="cpp" line="1">
<Material>
<Shader source="postGlow.shader.xml"/>
</Material>
</source>}}

{{CppSourceCode|
description= This context is designed to be added to the original skinning shaders - skinning.shader.xml and skinning_metal.shader.xml|
code=
<source lang="cpp" line="1">
<Context id="GLOWMASK">

<VertexShader>
<InsCode code="utilityLib/vertCommon.glsl" />
<InsCode code="utilityLib/vertSkinning.glsl" />
<DefCode>
<![CDATA[
void main( void )
{
// Calculate skinning matrices
mat4 skinningMat = calcSkinningMat();
mat3 skinningMatVec = getSkinningMatVec( skinningMat );
// Calculate world space position
vec4 pos = calcWorldPos( skinPos( gl_Vertex, skinningMat ) );
// Calculate clip space position
gl_Position = gl_ModelViewProjectionMatrix * pos;
}
]]>
</DefCode>
</VertexShader>

<FragmentShader>
<InsCode code="utilityLib/fragLighting.glsl" />
<DefCode>
<![CDATA[
void main( void )
{
gl_FragColor.rgb = vec3(0,0,0);
}
]]>
</DefCode>
</FragmentShader>
</Context>
</source>}}

== Example Result ==
[http://horde3d.org/forums/download/file.php?id=51 Click here to view]

== To-Do List for this Article ==
- Write the article, describe the code and pipeline changes required 
- Add pictures 
- Ask for permission to upload a ZIP of my finished xml/tga files ;) 

}}
| valign="top" | {{Extension_Summary
|name = Technique - Glow
|screenshot = todo.jpg
|description = Using an alpha channel to add emissive bloom.
|version = 1.0
|horde3dversion = 1.0 beta
|released = 2008-08-06
|author = [http://www.horde3d.org/forums/memberlist.php?mode=viewprofile&u=30 DarkAngel]|
}}
|}
[[category: Technique]]

User talk:Darkangel

2008-08-07T09:27:22Z

Darkangel:

Feel free to add any comments on my contributions to this talk page
#[[Shading Technique - Gloss Mapping]]
#[[Shading Technique - Glow Mapping]]

Shading Technique - Glow Mapping

2008-08-07T09:12:24Z

Darkangel:

{| border="0"
| {{ContentBlock|width=800|color=white
|content={{!!}}

'''I'm in the process of writing this article - come back later!'''

== Overview ==
For an in-depth overview of this technique, see the Gamasutra article [http://www.gamasutra.com/features/20040526/james_pfv.htm Real-Time Glow] by By Greg James and John O’Rorke.

== Temporary code dump ==
Until I finish writing this article, here's the undocumented code ;)

'''Pipeline changes'''

{{CppSourceCode|
description= Setup the RenderTargets. If this is for HDR, then these RenderTargets will already exist, so just change depthBuf to "true" on the first one|
code=
<source lang="cpp" line="1">
<stage id="Glow">
<RenderTarget id="BLURBUF1" depthBuf="true" numColBufs="1" format="RGBA8" bilinear="true" scale="0.25" />
<RenderTarget id="BLURBUF2" depthBuf="false" numColBufs="1" format="RGBA8" bilinear="true" scale="0.25" />
</stage>
</source>}}

{{CppSourceCode|
description= insert this new stage after the "Geometry" stage.|
code=
<source lang="cpp" line="1">
<stage id="Glow">
<SwitchTarget target="BLURBUF1" />
<ClearTarget depthBuf="true" colBuf0="true" />
<DrawGeometry context="GLOWMASK" />


<SwitchTarget target="BLURBUF2" />
<BindBuffer texUnit="0" target="BLURBUF1" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURV" />
<SwitchTarget target="BLURBUF1" />
<BindBuffer texUnit="0" target="BLURBUF2" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURH" />

<SwitchTarget target="BLURBUF2" />
<BindBuffer texUnit="0" target="BLURBUF1" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURV" />
<SwitchTarget target="BLURBUF1" />
<BindBuffer texUnit="0" target="BLURBUF2" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURH" />

<SwitchTarget target="BLURBUF2" />
<BindBuffer texUnit="0" target="BLURBUF1" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURV" />
<SwitchTarget target="BLURBUF1" />
<BindBuffer texUnit="0" target="BLURBUF2" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="BLURH" />


<SwitchTarget target="" />
<BindBuffer texUnit="0" target="BLURBUF1" bufIndex="0" />
<DrawQuad material="postGlow.material.xml" context="FINALPASS" />
</stage>
</source>}}

'''New shader code'''

{{CppSourceCode|
description= This context is designed to be added to a copy of the parallax shader - parallax_glow.shader.xml|
code=
<source lang="cpp" line="1">
<Context id="GLOWMASK">

<VertexShader>
<InsCode code="utilityLib/vertCommon.glsl" />
<DefCode>
<![CDATA[
uniform vec3 viewer;
attribute vec2 texCoords0;
attribute vec3 normal, tangent, bitangent;
varying vec3 eyeTS;
varying vec2 texCoords;
varying vec4 pos;

void main( void )
{
// Transform tangent space basis
vec3 tsbTangent = normalize( calcWorldVec( tangent ) );
vec3 tsbBitangent = normalize( calcWorldVec( bitangent ) );
vec3 tsbNormal = normalize( calcWorldVec( normal ) );

// Calculate world space position
pos = calcWorldPos( gl_Vertex );

// Eye vector and eye vector in tangent space
eyeTS = calcTanVec( viewer - pos.xyz, tsbTangent, tsbBitangent, tsbNormal );

// Calculate texture coordinates and clip space position
texCoords = texCoords0;
gl_Position = gl_ModelViewProjectionMatrix * pos;
}
]]>
</DefCode>
</VertexShader>

<FragmentShader>
<DefCode>
<![CDATA[
uniform sampler2D tex0;
varying vec3 eyeTS;
varying vec2 texCoords;

void main( void )
{
const float plxScale = 0.03;
const float plxBias = -0.015;

// Iterative parallax mapping
vec3 newCoords = vec3( texCoords, 0 );
vec3 eye = normalize( eyeTS );
for( int i = 0; i < 4; ++i )
{
vec4 nmap = texture2D( tex0, texCoords.st );
float height = nmap.a * plxScale + plxBias;
newCoords += (height - newCoords.p) * nmap.z * eye;
}

vec4 glow = texture2D( tex0, newCoords.st ).rgba;
glow *= glow.a;

gl_FragColor = glow;
}
]]>
</DefCode>
</FragmentShader>
</Context>
</source>}}

{{CppSourceCode|
description= This is a new shader, called postGlow.shader.xml|
code=
<source lang="cpp" line="1">
<Shader>

<Context id="BLURH">
<RenderConfig writeDepth="false" />
<VertexShader>
<DefCode>
<![CDATA[
varying vec2 texCoord;
void main( void )
{
texCoord = gl_MultiTexCoord0.st;
gl_Position = gl_ProjectionMatrix * gl_Vertex;
}
]]>
</DefCode>
</VertexShader>
<FragmentShader>
<InsCode code="utilityLib/fragPostProcess.glsl" />
<DefCode>
<![CDATA[
uniform sampler2D tex;
uniform vec2 frameBufSize;
varying vec2 texCoord;
void main( void )
{
float halfPixel = 0.5 / frameBufSize.x;
vec4 col = texture2D( tex, texCoord + vec2( halfPixel, 0.0 ) );
col += texture2D( tex, texCoord - vec2( halfPixel, 0.0 ) );
col += texture2D( tex, texCoord + vec2( halfPixel*3.0, 0.0 ) );
col += texture2D( tex, texCoord - vec2( halfPixel*3.0, 0.0 ) );
gl_FragColor = col * 0.25;
}
]]>
</DefCode>
</FragmentShader>
</Context>
<Context id="BLURV">
<RenderConfig writeDepth="false" />
<VertexShader>
<DefCode>
<![CDATA[
varying vec2 texCoord;
void main( void )
{
texCoord = gl_MultiTexCoord0.st;
gl_Position = gl_ProjectionMatrix * gl_Vertex;
}
]]>
</DefCode>
</VertexShader>
<FragmentShader>
<InsCode code="utilityLib/fragPostProcess.glsl" />
<DefCode>
<![CDATA[
uniform sampler2D tex;
uniform vec2 frameBufSize;
varying vec2 texCoord;
void main( void )
{
float halfPixel = 0.5 / frameBufSize.y;
vec4 col = texture2D( tex, texCoord + vec2( 0.0, halfPixel ) );
col += texture2D( tex, texCoord - vec2( 0.0, halfPixel ) );
col += texture2D( tex, texCoord + vec2( 0.0, halfPixel*3.0 ) );
col += texture2D( tex, texCoord - vec2( 0.0, halfPixel*3.0 ) );
gl_FragColor = col * 0.25;
}
]]>
</DefCode>
</FragmentShader>
</Context>

<Context id="FINALPASS">
<RenderConfig writeDepth="false" blendMode="ADD" />

<VertexShader>
<DefCode>
<![CDATA[
varying vec2 texCoord;

void main( void )
{
texCoord = gl_MultiTexCoord0.st;
gl_Position = gl_ProjectionMatrix * gl_Vertex;
}
]]>
</DefCode>
</VertexShader>

<FragmentShader>
<DefCode>
<![CDATA[
uniform sampler2D tex0, tex1;
uniform vec2 frameBufSize;
uniform vec4 hdrParams;
varying vec2 texCoord;

void main( void )
{
gl_FragColor = texture2D( tex0, texCoord ); // Glow color
}
]]>
</DefCode>
</FragmentShader>
</Context>
</Shader>
</source>}}

{{CppSourceCode|
description= The material to go with the postGlow shader - postGlow.material.xml|
code=
<source lang="cpp" line="1">
<Material>
<Shader source="postGlow.shader.xml"/>
</Material>
</source>}}

{{CppSourceCode|
description= This context is designed to be added to the original skinning shaders - skinning.shader.xml and skinning_metal.shader.xml|
code=
<source lang="cpp" line="1">
<Context id="GLOWMASK">

<VertexShader>
<InsCode code="utilityLib/vertCommon.glsl" />
<InsCode code="utilityLib/vertSkinning.glsl" />
<DefCode>
<![CDATA[
void main( void )
{
// Calculate skinning matrices
mat4 skinningMat = calcSkinningMat();
mat3 skinningMatVec = getSkinningMatVec( skinningMat );
// Calculate world space position
vec4 pos = calcWorldPos( skinPos( gl_Vertex, skinningMat ) );
// Calculate clip space position
gl_Position = gl_ModelViewProjectionMatrix * pos;
}
]]>
</DefCode>
</VertexShader>

<FragmentShader>
<InsCode code="utilityLib/fragLighting.glsl" />
<DefCode>
<![CDATA[
void main( void )
{
gl_FragColor.rgb = vec3(0,0,0);
}
]]>
</DefCode>
</FragmentShader>
</Context>
</source>}}

== Example Result ==
[http://horde3d.org/forums/download/file.php?id=51 Click here to view]

== To-Do List for this Article ==
- Write the article, describe the code and pipeline changes required 
- Add pictures 
- Ask for permission to upload a ZIP of my finished xml/tga files ;) 

}}
| valign="top" | {{Extension_Summary
|name = Technique - Glow
|screenshot = todo.jpg
|description = Using an alpha channel to add emissive bloom.
|version = 1.0
|horde3dversion = 1.0 beta
|released = 2008-08-06
|author = [http://www.horde3d.org/forums/memberlist.php?mode=viewprofile&u=30 DarkAngel]|
}}
|}
[[category: Technique]]

Shading Technique - Glow Mapping

2008-08-07T09:09:56Z

Darkangel: added a dump of my code until I actually finish writing this

Shading Technique - Glow Mapping

2008-08-06T10:54:22Z

Darkangel: draft

Shading Technique - Gloss Mapping

2008-08-06T10:41:58Z

Darkangel: done

{| border="0"
| {{ContentBlock|width=800|color=white
|content={{!!}}

== Overview ==
'''What is a gloss map?''' a texture that describes whether a surface area is [http://en.wikipedia.org/wiki/Gloss_%28material_appearance%29 matte or gloss]. This texture is used as a [http://en.wikipedia.org/wiki/Masking_%28in_art%29 mask] for specular highlights.

'''Why might you want to use this technique?''' 
- On materials that visibly vary in "shininess", such as reflective metal that is partially dirty. 

'''Requirements:''' 
- RGBA texture, with the RGB channels representing color (as usual) and the alpha channel representing the gloss map 
- Bright areas in the gloss map will by shiny, dark areas will be matte 

== The Technique ==
Seeing as specular lighting is already present in the shaders that are bundled with a new Horde3D installation, adding in a specular mask is exceedingly simple.

Only a few minor adjustments are required, in theory all we need to do is read the alpha channel from our texture and input that data into the specular lighting equations. I will make a modified version of the parallax shader to demonstrate how to make these additions. I'll make the changes for both the deferred and forward shading versions of the code.

The first step is the same for both the deferred and forward versions (i.e. the ATTRIBPASS and the LIGHTING contexts, respectively).
{{CppSourceCode|
description= GLSL Code to be modified in both ATTRIBPASS and LIGHTING.|
code=
<source lang="cpp" line="1">
//This line reads the RGB values of our texture, comment it out:
//vec3 albedo = texture2D( tex0, newCoords.st ).rgb;
//And then replace it with this code that also reads the alpha channel:
vec4 albedo_gloss = texture2D( tex0, newCoords.st ).rgba;
vec3 albedo = albedo_gloss.rgb;
float gloss = albedo_gloss.a;
</source>}}

This next change is for the forward shading version only.
{{CppSourceCode|
description= GLSL Code to be modified in LIGHTING.|
code=
<source lang="cpp" line="1">
//This line of code performs the lighting equation. The first hard-coded values of 0.3 is the specular mask value.
//gl_FragColor.rgb =
// calcPhongSpotLight( newPos, normalize( normal ), albedo, 0.3, 16.0, -vsPos.z, 0.3 );
//Change the first "0.3" value to "gloss", Like this:
gl_FragColor.rgb =
calcPhongSpotLight( newPos, normalize( normal ), albedo, gloss, 16.0, -vsPos.z, 0.3 );
</source>}}

This next change is for the deferred shading version only.
{{CppSourceCode|
description= GLSL Code to be modified in ATTRIBPASS.|
code=
<source lang="cpp" line="1">
//This line of code saves the material properties. The hard-coded value of 0.3 is the specular mask value.
//setSpecMask( 0.3 );
//Change the "0.3" value to "gloss", Like this:
setSpecMask( gloss );
</source>}}

== Example Result ==
[http://horde3d.org/forums/download/file.php?id=50 Click here to view]

== To-Do List for this Article ==
- Add pictures 
- Ask for permission to upload a ZIP of my finished xml/tga files ;) 

}}
| valign="top" | {{Extension_Summary
|name = Technique - Gloss mapping
|screenshot = todo.jpg
|description = Using an alpha channel to mask specular highlights.
|version = 1.0
|horde3dversion = 1.0 beta
|released = 2008-08-06
|author = [http://www.horde3d.org/forums/memberlist.php?mode=viewprofile&u=30 DarkAngel]|
}}
|}
[[category: Technique]]

Shading Technique - Gloss Mapping

2008-08-06T10:41:06Z

Darkangel:

{| border="0"
| {{ContentBlock|width=800|color=white
|content={{!!}}

== Overview ==
'''What is a gloss map?''' a texture that describes whether a surface area is [http://en.wikipedia.org/wiki/Gloss_%28material_appearance%29 matte or gloss]. This texture is used as a [http://en.wikipedia.org/wiki/Masking_%28in_art%29 mask] for specular highlights.

'''Why might you want to use this technique?''' 
- On materials that visibly vary in "shininess", such as reflective metal that is partially dirty. 

'''Requirements:''' 
- RGBA texture, with the RGB channels representing color (as usual) and the alpha channel representing the gloss map 
- Bright areas in the gloss map will by shiny, dark areas will be matte 

== The Technique ==
Seeing as specular lighting is already present in the shaders that are bundled with a new Horde3D installation, adding in a specular mask is exceedingly simple.

Only a few minor adjustments are required, in theory all we need to do is read the alpha channel from our texture and input that data into the specular lighting equations. I will make a modified version of the parallax shader to demonstrate how to make these additions. I'll make the changes for both the deferred and forward shading versions of the code.

The first step is the same for both the deferred and forward versions (i.e. the ATTRIBPASS and the LIGHTING contexts, respectively).
{{CppSourceCode|
description= GLSL Code to be modified in both ATTRIBPASS and LIGHTING.|
code=
<source lang="cpp" line="1">
//This line reads the RGB values of our texture, comment it out:
//vec3 albedo = texture2D( tex0, newCoords.st ).rgb;
//And then replace it with this code that also reads the alpha channel:
vec4 albedo_gloss = texture2D( tex0, newCoords.st ).rgba;
vec3 albedo = albedo_gloss.rgb;
float gloss = albedo_gloss.a;
</source>}}

This next change is for the forward shading version only.
{{CppSourceCode|
description= GLSL Code to be modified in LIGHTING.|
code=
<source lang="cpp" line="1">
//This line of code performs the lighting equation. The first hard-coded values of 0.3 is the specular mask value.
//gl_FragColor.rgb =
// calcPhongSpotLight( newPos, normalize( normal ), albedo, 0.3, 16.0, -vsPos.z, 0.3 );
//Change the first "0.3" value to "gloss", Like this:
gl_FragColor.rgb =
calcPhongSpotLight( newPos, normalize( normal ), albedo, gloss, 16.0, -vsPos.z, 0.3 );
</source>}}

This next change is for the deferred shading version only.
{{CppSourceCode|
description= GLSL Code to be modified in ATTRIBPASS.|
code=
<source lang="cpp" line="1">
//This line of code saves the material properties. The hard-coded value of 0.3 is the specular mask value.
//setSpecMask( 0.3 );
//Change the "0.3" value to "gloss", Like this:
setSpecMask( gloss );
</source>}}

== Example Result ==
[http://horde3d.org/forums/download/file.php?id=50 Click here to view]

== To-Do List for this Article ==
- Add pictures 
- Finish writing the descriptions ;) - this is a draft 

}}
| valign="top" | {{Extension_Summary
|name = Technique - Gloss mapping
|screenshot = todo.jpg
|description = Using an alpha channel to mask specular highlights.
|version = 1.0
|horde3dversion = 1.0 beta
|released = 2008-08-06
|author = [http://www.horde3d.org/forums/memberlist.php?mode=viewprofile&u=30 DarkAngel]|
}}
|}
[[category: Technique]]

Shading Technique - Gloss Mapping

2008-08-06T10:33:07Z

Darkangel:

{| border="0"
| {{ContentBlock|width=800|color=white
|content={{!!}}

'''I'm still writing this article, based on [http://www.horde3d.org/forums/viewtopic.php?f=1&t=446 this forum post]'''

== Overview ==
'''What is a gloss map?''' a texture that describes whether a surface area is [http://en.wikipedia.org/wiki/Gloss_%28material_appearance%29 matte or gloss]. This texture is used as a [http://en.wikipedia.org/wiki/Masking_%28in_art%29 mask] for specular highlights.

'''Why might you want to use this technique?''' 
- On materials that visibly vary in "shininess", such as reflective metal that is partially dirty. 

'''Requirements:''' 
- RGBA texture, with the RGB channels representing color (as usual) and the alpha channel representing the gloss map 
- Bright areas in the gloss map will by shiny, dark areas will be matte 

== The Technique ==
Seeing as specular lighting is already present in the shaders that are bundled with a new Horde3D installation, adding in a specular mask is exceedingly simple.

Only a few minor adjustments are required, in theory all we need to do is read the alpha channel from our texture and input that data into the specular lighting equations. I will make a modified version of the parallax shader to demonstrate how to make these additions. I'll make the changes for both the deferred and forward shading versions of the code.

The first step is the same for both the deferred and forward versions (i.e. the ATTRIBPASS and the LIGHTING contexts, respectively).
{{CppSourceCode|
description= GLSL Code to be modified in both ATTRIBPASS and LIGHTING.|
code=
<source lang="cpp" line="1">
//This line reads the RGB values of our texture, comment it out:
//vec3 albedo = texture2D( tex0, newCoords.st ).rgb;
//And then replace it with this code that also reads the alpha channel:
vec4 albedo_gloss = texture2D( tex0, newCoords.st ).rgba;
vec3 albedo = albedo_gloss.rgb;
float gloss = albedo_gloss.a;
</source>}}

This next change is for the forward shading version only.
{{CppSourceCode|
description= GLSL Code to be modified in LIGHTING.|
code=
<source lang="cpp" line="1">
//This line of code performs the lighting equation. The first hard-coded values of 0.3 is the specular mask value.
//gl_FragColor.rgb =
// calcPhongSpotLight( newPos, normalize( normal ), albedo, 0.3, 16.0, -vsPos.z, 0.3 );
//Change the first "0.3" value to "gloss", Like this:
gl_FragColor.rgb =
calcPhongSpotLight( newPos, normalize( normal ), albedo, gloss, 16.0, -vsPos.z, 0.3 );
</source>}}

This next change is for the deferred shading version only.
{{CppSourceCode|
description= GLSL Code to be modified in ATTRIBPASS.|
code=
<source lang="cpp" line="1">
//This line of code saves the material properties. The hard-coded value of 0.3 is the specular mask value.
//setSpecMask( 0.3 );
//Change the "0.3" value to "gloss", Like this:
setSpecMask( gloss );
</source>}}

== Example Result ==
Insert image here

== To-Do List for this Article ==
- Add pictures 
- Finish writing the descriptions ;) - this is a draft 

}}
| valign="top" | {{Extension_Summary
|name = Technique - Gloss mapping
|screenshot = todo.jpg
|description = Using an alpha channel to mask specular highlights.
|version = 1.0
|horde3dversion = 1.0 beta
|released = 2008-08-06
|author = [http://www.horde3d.org/forums/memberlist.php?mode=viewprofile&u=30 DarkAngel]|
}}
|}
[[category: Technique]]

Shading Technique - Gloss Mapping

2008-08-06T10:20:52Z

Darkangel:

{| border="0"
| {{ContentBlock|width=800|color=white
|content={{!!}}

'''I'm still writing this article, based on [http://www.horde3d.org/forums/viewtopic.php?f=1&t=446 this forum post]'''

== Overview ==
'''What is a gloss map?''' a texture that describes whether a surface area is [http://en.wikipedia.org/wiki/Gloss_%28material_appearance%29 matte or gloss]. This texture is used as a [http://en.wikipedia.org/wiki/Masking_%28in_art%29 mask] for specular highlights.

'''Why might you want to use this technique?''' 
- On materials that visibly vary in "shininess", such as reflective metal that is partially dirty. 

'''Requirements:''' 
- RGBA texture, with the RGB channels representing color (as usual) and the alpha channel representing the gloss map 
- Bright areas in the gloss map will by shiny, dark areas will be matte 

== The Technique ==
Seeing as specular lighting is already present in the shaders that are bundled with a new Horde3D installation, adding in a specular mask is exceedingly simple.

Only a few minor adjustments are required, in theory all we need to do is read the alpha channel from our texture and input that data into the specular lighting equations. I will make a modified version of the parallax shader to demonstrate how to make these additions. I'll make the changes for both the deferred and forward shading versions of the code.

The first step is the same for both the deferred and forward versions (i.e. the ATTRIBPASS and the LIGHTING contexts, respectively).
{{CppSourceCode|
description= GLSL Code to be modified in both ATTRIBPASS and LIGHTING.|
code=
<source lang="cpp" line="1">
//This line reads the RGB values of our texture, comment it out:
//vec3 albedo = texture2D( tex0, newCoords.st ).rgb;
//And then replace it with this code that also reads the alpha channel:
vec4 albedo_gloss = texture2D( tex0, newCoords.st ).rgba;
vec3 albedo = albedo_gloss.rgb;
float gloss = albedo_gloss.a;
</source>}}

This next change is for the forward shading version only.
{{CppSourceCode|
description= GLSL Code to be modified in LIGHTING.|
code=
<source lang="cpp" line="1">
//This line of code performs the lighting equation. The hard-coded values of 0.3 are the specular values.
//gl_FragColor.rgb =
// calcPhongSpotLight( newPos, normalize( normal ), albedo, 0.3, 16.0, -vsPos.z, 0.3 );
//Change the "0.3" values to "gloss", Like this:
gl_FragColor.rgb =
calcPhongSpotLight( newPos, normalize( normal ), albedo, gloss, 16.0, -vsPos.z, gloss );
</source>}}

This next change is for the deferred shading version only.
{{CppSourceCode|
description= GLSL Code to be modified in ATTRIBPASS.|
code=
<source lang="cpp" line="1">
//This line of code saves the material properties. The hard-coded value of 0.3 is the specular value.
setSpecMask( gloss );
//Change the "0.3" values to "gloss", Like this:
setSpecMask( 0.3 );
</source>}}

== Example Result ==
Insert image here

== To-Do List for this Article ==
- Add pictures 
- Finish writing the descriptions ;) - this is a draft 

}}
| valign="top" | {{Extension_Summary
|name = Technique - Gloss mapping
|screenshot = todo.jpg
|description = Using an alpha channel to mask specular highlights.
|version = 1.0
|horde3dversion = 1.0 beta
|released = 2008-08-06
|author = [http://www.horde3d.org/forums/memberlist.php?mode=viewprofile&u=30 DarkAngel]|
}}
|}
[[category: Technique]]

Shading Technique - Gloss Mapping

2008-08-06T04:15:43Z

Darkangel: Draft layout

Horde3D Wiki:Community portal

2008-08-06T02:17:09Z

Darkangel: Glow and Gloss mapping links

__NOEDITSECTION__{{ContentBlock|width=800|color=orange
|content= '''The community portal section of the Horde3D wiki contains community contributed articles that are not part of the official documentation. Feel free to add articles to our wiki or links to external tutorials.'''}}
{{SpacerBlock}}
{{ContentBlock|width=800
|header=Horde3D is a cross-platform graphics engine. The currently supported platform are Windows, Linux and Mac OS X.
|content={{!!}}
==How-To setup a Horde3D Development Environment==
*[[Horde3D Development Environment for Windows]]
*[[Horde3D Development Environment for Linux]]
*[[Horde3D Development Environment for Mac OS X]]

*[[Horde3D Development Environment from SVN]]

==Tutorials==
[[Category: Tutorials]]

Fell free to write your tutorials here, for the benefit of the whole community.
===Beginner===
#[[Tutorial - Hello World]] - In this section we will create a simple application that loads a character and animates it using a walk cycle.
#[[Tutorial - Picking]] - In this section we will demonstrate picking the node under the mouse cursor
#[[Tutorial - Simple HUD]] - How to use showOverlay to create a simple HUD.
#[[Tutorial - Setup Horde with SDL]] - How to Setup Horde with SDL.
#[[Tutorial - Setup Horde with Qt4]] - How to Setup Horde with Qt4.
===Intermediate===

===Advanced===

==Techniques==
[[Category: Techniques]]

===Shading===
#[[Shading Technique - Dot Product Detail Texturing]] - Using the dot product of vectors and signed textures for high frequency detail
#[[Shading Technique - Palette Coloring]] - Quick and dirty palette recoloration of objects
#[[Shading Technique - Gloss Mapping]] - Mask which areas of an object have specular highlights
#[[Shading Technique - Glow Mapping]] - Allow areas on an object to emit a strong glowing highlight

==Content Import==
[[Category: Content Import]]
#[[Collada - 3DS Max and Maya]] - Exporting from 3D Studio Max and Maya.
#[[Collada - Modo]] - Exporting from Modo.
#[[Collada - Blender]] - Exporting from Blender.
}}

User talk:Darkangel

2008-04-09T01:09:57Z

Darkangel: New page: Just testing... Congrat's on the new forum and wiki Nicolas!

Just testing...

Congrat's on the new forum and wiki Nicolas!