/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2004 Blender Foundation.
 * All rights reserved.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef __BKE_DEPSGRAPH_H__
#define __BKE_DEPSGRAPH_H__

/** \file BKE_depsgraph.h
 *  \ingroup bke
 */

/* Dependency Graph
 *
 * The dependency graph tracks relations between datablocks, and is used to
 * determine which datablocks need to be update based on dependencies and
 * visibility.
 *
 * It does not itself execute changes in objects, but rather sorts the objects
 * in the appropriate order and sets flags indicating they should be updated.
 */

#ifdef __cplusplus
extern "C" {
#endif

struct ID;
struct Main;
struct Object;
struct Scene;

/* Dependency graph evaluation context
 *
 * This structure stores all the local dependency graph data,
 * which is needed for it's evaluation,
 */
typedef struct EvaluationContext {
	int mode;               /* evaluation mode */
	float ctime;            /* evaluation time */
} EvaluationContext;

typedef enum eEvaluationMode {
	DAG_EVAL_VIEWPORT       = 0,    /* evaluate for OpenGL viewport */
	DAG_EVAL_PREVIEW        = 1,    /* evaluate for render with preview settings */
	DAG_EVAL_RENDER         = 2,    /* evaluate for render purposes */
} eEvaluationMode;

/* DagNode->eval_flags */
enum {
	/* Regardless to curve->path animation flag path is to be evaluated anyway,
	 * to meet dependencies with such a things as curve modifier and other guys
	 * who're using curve deform, where_on_path and so.
	 */
	DAG_EVAL_NEED_CURVE_PATH = 1,
	/* Scene evaluation would need to have object's data on CPU,
	 * meaning no GPU shortcuts is allowed.
	 */
	DAG_EVAL_NEED_CPU        = 2,
};

/* Global initialization/deinitialization */
void DAG_init(void);
void DAG_exit(void);

/* Build and Update
 *
 * DAG_scene_relations_update will rebuild the dependency graph for a given
 * scene if needed, and sort objects in the scene.
 *
 * DAG_relations_tag_update will clear all dependency graphs and mark them to
 * be rebuilt later. The graph is not rebuilt immediately to avoid slowdowns
 * when this function is call multiple times from different operators.
 *
 * DAG_scene_relations_rebuild forces an immediaterebuild of the dependency
 * graph, this is only needed in rare cases
 */

void DAG_scene_relations_update(struct Main *bmain, struct Scene *sce);
void DAG_scene_relations_validate(struct Main *bmain, struct Scene *sce);
void DAG_relations_tag_update(struct Main *bmain);
void DAG_scene_relations_rebuild(struct Main *bmain, struct Scene *scene);
void DAG_scene_free(struct Scene *sce);

/* Update Tagging
 *
 * DAG_scene_update_flags will mark all objects that depend on time (animation,
 * physics, ..) to be recalculated, used when changing the current frame.
 * 
 * DAG_on_visible_update will mark all objects that are visible for the first
 * time to be updated, for example on file load or changing layer visibility.
 *
 * DAG_id_tag_update will mark a given datablock to be updated. The flag indicates
 * a specific subset to be update (only object transform and data for now).
 *
 * DAG_id_type_tag marks a particular datablock type as having changing. This does
 * not cause any updates but is used by external render engines to detect if for
 * example a datablock was removed. */

void DAG_scene_update_flags(struct Main *bmain, struct Scene *sce, unsigned int lay, const bool do_time, const bool do_invisible_flush);
void DAG_on_visible_update(struct Main *bmain, const bool do_time);

void DAG_id_tag_update(struct ID *id, short flag);
void DAG_id_tag_update_ex(struct Main *bmain, struct ID *id, short flag);
void DAG_id_type_tag(struct Main *bmain, short idtype);
int  DAG_id_type_tagged(struct Main *bmain, short idtype);

/* Flushing Tags
 *
 * DAG_scene_flush_update flushes object recalculation flags immediately to other
 * dependencies. Do not use outside of depsgraph.c, this will be removed.
 *
 * DAG_ids_flush_tagged will flush datablock update flags flags to dependencies,
 * use this right before updating to mark all the needed datablocks for update.
 *
 * DAG_ids_check_recalc and DAG_ids_clear_recalc are used for external render
 * engines to detect changes. */

void DAG_scene_flush_update(struct Main *bmain, struct Scene *sce, unsigned int lay, const short do_time);
void DAG_ids_flush_tagged(struct Main *bmain);
void DAG_ids_check_recalc(struct Main *bmain, struct Scene *scene, bool time);
void DAG_ids_clear_recalc(struct Main *bmain);

/* Armature: sorts the bones according to dependencies between them */

void DAG_pose_sort(struct Object *ob);

/* Editors: callbacks to notify editors of datablock changes */

void DAG_editors_update_cb(void (*id_func)(struct Main *bmain, struct ID *id),
                           void (*scene_func)(struct Main *bmain, struct Scene *scene, int updated),
                           void (*scene_pre_func)(struct Main *bmain, struct Scene *scene, bool time));

void DAG_editors_update_pre(struct Main *bmain, struct Scene *scene, bool time);

/* ** Threaded update ** */

/* Initialize the DAG for threaded update. */
void DAG_threaded_update_begin(struct Scene *scene,
                               void (*func)(void *node, void *user_data),
                               void *user_data);

void DAG_threaded_update_handle_node_updated(void *node_v,
                                             void (*func)(void *node, void *user_data),
                                             void *user_data);

/* Debugging: print dependency graph for scene or armature object to console */

void DAG_print_dependencies(struct Main *bmain, struct Scene *scene, struct Object *ob);

/* ************************ DAG querying ********************* */

struct Object *DAG_get_node_object(void *node_v);
const char *DAG_get_node_name(struct Scene *scene, void *node_v);
short DAG_get_eval_flags_for_object(struct Scene *scene, void *object);
bool DAG_is_acyclic(struct Scene *scene);

#ifdef __cplusplus
}
#endif
		
#endif
