render plan api plan

// Create render plan objects                                                                                                                 
gfks_render_plan *deferred_render_plan = gfks_create_render_plan(context);                                                                    
                                                                                                                                              
gfks_render_pass *geometry_pass        = gfks_create_render_pass(context);                                                                    
gfks_render_pass *diffuse_pass         = gfks_create_render_pass(context);                                                                    
gfks_render_pass *specular_pass        = gfks_create_render_pass(context);                                                                    
gfks_render_pass *composite_pass       = gfks_create_render_pass(context);                                                                    
                                                                                                                                              
// Add passes to our plan (order does not matter)                                                                                             
deferred_render_plan->add_render_pass(deferred_render_plan, geometry_pass);                                                                   
deferred_render_plan->add_render_pass(deferred_render_plan, diffuse_pass);                                                                    
deferred_render_plan->add_render_pass(deferred_render_plan, specular_pass);                                                                   
deferred_render_plan->add_render_pass(deferred_render_plan, composite_pass);                                                                  
                                                                                                                                              
// Define dependencies                                                                                                                        
diffuse_pass->depends_on(diffuse_pass, geometry_pass);                                                                                        
specular_pass->depends_on(specular_pass, geometry_pass);                                                                                      
composite_pass->depends_on(composite_pass, diffuse_pass);                                                                                     
composite_pass->depends_on(composite_pass, specular_pass);                                                                                    
                                                                                                                                              
// Set up render pass info                                                                                                                    
//                                                                                                                                            
// def_shaderset_attr_* defines the existance of an input for a specified chain of shaders -                                                  
// the 2nd arg is always the shaderset index within the pass info we want to feed this input to                                               
// the 3nd arg is always an input index for the shader. The data type within the shader depends on the call.                                  
uint32_t shaderset_index = diffuse_pass->add_shaderset(shaders);                                                                              
diffuse_pass->def_shaderset_attr_meshes(diffuse_pass, shaderset_index, 0);                                                                    
diffuse_pass->def_shaderset_attr_mesh_vertex_colors(diffuse_pass, shaderset_index, 1);                                                        
diffuse_pass->def_shaderset_attr_global_transformation_matrix(diffuse_pass, shaderset_index, 2);                                              
diffuse_pass->def_shaderset_attr_mesh_transformation_matrix(diffuse_pass, shaderset_index, 3);                                                
diffuse_pass->def_shaderset_attr_previous_pass(diffuse_pass, shaderset_index, 4, geometry_pass); // should error here if we don't have the dep
// etc etc for other passes                                                                                                                   
                                                                                                                                              
// Define the surface(s) that we want to be presented to                                                                                      
deferred_render_plan->add_presentation_surface(deferred_render_plan, surface);                                                                
                                                                                                                                              
// All done planning - finalize the plan!                                                                                                     
deferred_render_plan->finalize_plan();                                                                                                        
                                                                                                                                              
// Give our passes some input data                                                                                                            
//                                                                                                                                            
// set_shaderset_attr_* sets the value of a specified attr, and can be called any number of times                                             
// 2nd arg is always the input index for the shader (we already have a unique ID, no need to make another)                                    
diffuse_pass->set_shaderset_attr_meshes(diffuse_pass, 0, mesh_array); // mesh_array could be a gfks_meshgroup object to do your memory stuffs 
diffuse_pass->set_shaderset_attr_mesh_vertex_colors(diffuse_pass, 1, mesh_index, color_array);                                                
diffuse_pass->set_shaderset_attr_global_transformation_matrix(diffuse_pass, 2, matrix);                                                       
diffuse_pass->set_shaderset_attr_mesh_transformation_matrix(diffuse_pass, 3, mesh_index, matrix);                                             
// etc etc for other passes                                                                                                                   
                                                                                                                                              
// Draw loop                                                                                                                                  
while (drawing frames) {                                                                                                                      
  deferred_render_plan.execute()                                                                                                              
}