struct GeometryPacket  
 {    
     Primitive mPrimType;    
     void* mVertices;   
     unsigned int mVertexStride;      //顶点列表
     unsigned short* mIndices;      //索引列表
     unsigned int mVertexCount;    // 顶点数
     unsigned int mIndexCount;      // 索引数 
     D3DXVECTOR3 mSphereCentre;   // 包围球中心
     float mSphereRadius;   // 包围球半径
 }; 

struct InstanceAttributes  {    
    D3DXMATRIX mModelMatrix;    // 模型矩阵
    D3DCOLOR mInstanceColor;    // Instance 颜色
};

struct GeometryInstance  {    
    GeometryPacket* mGeometryPacket;    
    InstanceAttributes mInstanceAttributes;  
}; 

// 渲染下文
class RenderContext  {  
public:     
    // 开始设置 render context，使渲染状态激活
    void Begin(void);      
    // 关闭 render context，还原之前的状态    
    void End(void);    
private:      
    // render state、pixel shader、vertex shader
    // ...
};    

// 需要用到的纹理
class TextureContext  {     
    Texture mDiffuseMap;    
    Texture mLightMap;      
    // . . .    
}; 

class GeometryBatch  {  
public:      
    // 清楚batch当中包含的全部Instance  
    virtual void ClearInstances(void);      
    // 添加一个Instance 返回Instance ID 
    // 如果不能在添加返回-1
    virtual int AddInstance(GeometryInstance* instance);      
    // 提交所有Instance, 渲染循环之前调用一次，或者Instance发生变化之后。  
    virtual unsigned int Commit(void) = 0;      
    /* 
    更新Geometry batch, 最终会准备GPU数据提交给驱动程序，如果需要也回填充indexbuffer和vertexbuffer ，每帧调用一次。
	*/     
    virtual void Update(void) = 0;     
    // 将batch提交给驱动程序，通常就是一次drawcall，一次DrawIndexedPrimitive的调用。 
    virtual void Render(void) const = 0;    
    
private:   
    // Instance的列表
    GeometryInstancesCollection mInstances;      
   
}; 

// 遍历所有的drawcall，也就是所有的batch
Foreach GeometryBatch in ActiveBatchesList    
	// 更新这个batch
    GeometryBatch.Update();    
    // Render phase  
    Foreach RenderContext  
    Begin    
    	// 渲染状态
        RenderContext.BeginRendering();    
        RenderContext.CommitStates();    
		// 贴图状态
        Foreach TextureContext      
            Begin      
            	//应用贴图
                TextureContext.Apply();    
			   // 渲染Batch中的所有instance
                Foreach GeometryBatch in the texture context        
                	GeometryBatch.Render();    
            End  
    End 

HRESULT res;    
res = lpDevice->CreateVertexBuffer(MAX_STATIC_BUFFER_SIZE,    
                                   D3DUSAGE_WRITEONLY,    
                                   0,    
                                   D3DPOOL_MANAGED,    
                                   &mStaticVertexStream,    
                                   0);    
ENGINE_ASSERT(SUCCEEDED(res)); 

// 遍历每一个Batch当中的instance
Foreach GeometryInstance in Instances  
Begin    
	// 将所有的instance都转换到同一个空间。
    Transform geometry in mGeometryPacket to world space      with instance mModelMatrix    
    // 应用所有的instance属性
    Apply other instance attributes (like instance color)    
    // 将转换后的几何信息保存的vertex buffer
    Copy transformed geometry to the Vertex Buffer    
    // 将索引根据不同instance增加一个offet保存到Indexbuffer
	Copy indices (with the right offset) to the Index Buffer  
End 

HRESULT res;    
res = lpDevice->CreateVertexBuffer(MAX_DYNAMIC_BUFFER_SIZE,    
                                   D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY,    
                                   0,    
                                   D3DPOOL_DEFAULT,    
                                   &mDynamicVertexStream,    
                                   0); 

Foreach GeometryInstance in Instances  
	Begin    
 		Transform geometry in mGeometryPacket to world space with      instance mModelMatrix    
 		If instance needs skinning, request a set of bones from      mAnimationPlayer and skin geometry    
 		Apply other instance attributes (like instance color)    
 		Copy transformed geometry to the Vertex Buffer    
 		Copy indices (with the right offset) to the Index Buffer    
		Advance current pointer to the Vertex Buffer    
		Advance current pointer to the Index Buffer  
    End 

DrawIndexedPrimitive().

 struct InstanceVertex  {    
     D3DXVECTOR3  mPosition; // Other vertex properties, such as normal and texture    
     // coordinates      
     WORD  mInstanceIndex[4]; // Direct3D requires SHORT4  
 }; 

D3DXVECTOR4 instancesData[MAX_NUMBER_OF_CONSTANTS];    
unsigned int count = 0;    
for (unsigned int i = 0; i < GetInstancesCount(); ++i)  {    
    // write model matrix    
    instancesData[count++] = *(D3DXVECTOR4*)        
    &mInstances[i].mModelMatrix.m11;    
    instancesData[count++] = *(D3DXVECTOR4*)        
    &mInstances[i].mModelMatrix.m21;    
    instancesData[count++] = *(D3DXVECTOR4*)        
    &mInstances[i].mModelMatrix.m31;    
    instancesData[count++] = *(D3DXVECTOR4*)        
    &mInstances[i].mModelMatrix.m41;      
    // write instance color      
    instanceData[count++] = ConvertColorToVec4(mInstances[i].mColor));  
}    
lpDevice->SetVertexConstants(    
    INSTANCES_DATA_FIRST_CONSTANT,    
    instancesData,    
    count); 

 HRESULT SetStreamSourceFreq(    UINT StreamNumber,    UINT FrequencyParameter); 

unsigned int instancesCount = GetInstancesCount();    
// set up stream source frequency for the first stream  
// to render instancesCount instances  
// D3DSTREAMSOURCE_INDEXEDDATA tells Direct3D we'll use  
// indexed geometry for instancing  
lpDevice->SetStreamSourceFreq(    0,    D3DSTREAMSOURCE_INDEXEDDATA | instancesCount);      
// set up first stream source with the vertex buffer  
// containing geometry for the geometry packet  
lpDevice->SetStreamSource(    0,    mGeometryInstancingVB[0],    0,    mGeometryPacketDecl);    
// set up stream source frequency for the second stream;  
// each set of instance attributes describes one instance  
// to be rendered  
lpDevice->SetStreamSourceFreq(    1,    D3DSTREAMSOURCE_INSTANCEDATA | 1);    // set up second stream source with the vertex buffer    
// containing all instances' attributes  
pd3dDevice->SetStreamSource(    1,    mGeometryInstancingVB[0],    0,    mInstancesDataVertexDecl); 

 // vertex input declaration  
struct vsInput  
{    
    // stream 0    
    float4 position : POSITION;    
    float3 normal   : NORMAL;      
    // stream 1      
    float4 model_matrix0 : TEXCOORD0;    
    float4 model_matrix1 : TEXCOORD1;    
    float4 model_matrix2 : TEXCOORD2;    
    float4 model_matrix3 : TEXCOORD3;      
    float4 instance_color : D3DCOLOR;  
};      
vsOutput GeometryInstancingVS(    in vsInput input)  
{    
    // construct the model matrix    
    float4x4 modelMatrix =    {      
        input.model_matrix0,      
        input.model_matrix1,      
        input.model_matrix2,      
        input.model_matrix3    
    };      
    // transform input position and normal to world space    
    // with the instance model matrix      
    float4 worldPosition = mul(input.position, modelMatrix);    
    float3 worldNormal = mul(input.normal, modelMatrix);      
    // output position, normal, and color    
    output.position = mul(worldPosition, ViewProjectionMatrix);    
    output.normal = mul(worldNormal, ViewProjectionMatrix);    
    output.color = input.instance_color;      
    // output other vertex data    
}