#ifndef _CASM_NODE_DEFINED_H

#define _CASM_NODE_DEFINED_H

#include "raster.h"

#include "casm.h"

#include "tmacro.h"

#include "affine.h"

#include "toonzproc.h"

#define CASM_NODE_HD            \

	struct CASM_NODEPROC *proc; \

	char bg_flag, bad_branch;   \

	ULONG mask;                 \

	int label;

#define CASM_UNARY_NODE_HD \

	CASM_NODE_HD           \

	CASM_NODE *arg;

#define CASM_BINARY_NODE_HD     \

	CASM_NODE_HD                \

	CASM_NODE *arg_dn, *arg_up; \

	int marker_dn, marker_up;

#define CASM_N_ARY_NODE_HD \

	CASM_NODE_HD           \

	int num_args;          \

	CASM_NODE **args;

typedef struct CASM_NODE {

	CASM_NODE_HD

} CASM_NODE;

typedef struct CASM_TILE {

	RASTER r;

	int x1, y1, x2, y2;

} CASM_TILE;

typedef struct CASM_NODESIZE {

	float x1, y1, x2, y2;

	float sbx1, sby1, sbx2, sby2;

} CASM_NODESIZE;

typedef struct USR_IMAGE {

	void *buffer;

	enum img_type type;

	int wrap, lx, ly;

	struct {

		LPIXEL *buffer;

		int offset, size;

	} cmap;

} USR_IMAGE;

enum CASM_NODE_TYPE {

	OVR_TRANSF = 0,

	ADD_TRANSF,

	BACKLIT_TRANSF,

	MATTE_TRANSF,

	WARP_TRANSF,

	BLUR_TRANSF,

	MBLUR_TRANSF,

	UDIT_TRANSF,

	READ_TRANSF,

	FLIPX_TRANSF,

	FLIPY_TRANSF,

	EXTOP_TRANSF,

	COLOR_TRANSF,

	COLORCARD_TRANSF,

	AFFINE_TRANSF,

	SHARPEN_TRANSF,

	LOCALBLUR_TRANSF,

	LOCALTRANSP_TRANSF,

	BODY_SHADOW_TRANSF,

	REFLECTION_TRANSF,

	CASM_NODE_TYPE_HOW_MANY

};

typedef int CASM_COMPUTE_FUNCTION(CASM_NODE *node,

								  int x1, int y1, int x2, int y2,

								  float dx, float dy,

								  RASTER *raster, CASM_TILE *out);

typedef void CASM_CE_FUNCTION(float *pars, int cx, int cy,

							  RASTER *rin, RASTER *rout, int shrink);

typedef struct CASM_RENDER_INFO {

	float dx, dy;

	int shrink;

	int frame;

	int column;

} CASM_RENDER_INFO;

typedef void CASM_CLC_FUNCTION(float *pars, CASM_RENDER_INFO *info, RASTER *rout);

typedef int CASM_COMPARE_FUNCTION(CASM_NODE *n1, CASM_NODE *n2);

typedef void CASM_WRITE_FUNCTION(CASM_NODE *node, T_CHAN fp);

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODEPROC {

	CASM_COMPUTE_FUNCTION *compute;

	CASM_COMPARE_FUNCTION *compare;

	CASM_WRITE_FUNCTION *write;

	int record_size;

} CASM_NODEPROC;

/*----------------------------------------------------------------------------*/

typedef struct CASM_FRAME {

	struct CASM_FRAME *next;

	CASM_NODE *node;

	char *filename;

} CASM_FRAME;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_ADD {

	CASM_BINARY_NODE_HD

	int diff_values;

	float value;

	TBOOL is_add, dont_use_matte;

} CASM_NODE_ADD;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_LOCALBLUR {

	CASM_BINARY_NODE_HD

	float value;

} CASM_NODE_LOCALBLUR;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_LOCALTRANSP {

	CASM_BINARY_NODE_HD

	float value;

} CASM_NODE_LOCALTRANSP;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_BLUR {

	CASM_UNARY_NODE_HD

	float blur;

	int backlit;

} CASM_NODE_BLUR;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_MBLUR {

	CASM_UNARY_NODE_HD

	double bx;

	double by;

} CASM_NODE_MBLUR;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_BODY_SHADOW {

	CASM_UNARY_NODE_HD

	TPOINT p;

	int blur;

	float transp;

	TBOOL is_highlight;

} CASM_NODE_BODY_SHADOW;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_REFLECTION {

	CASM_UNARY_NODE_HD

	float stretch_x;

	float stretch_y;

	float skew;

	float blur_min;

	float blur_max;

	float transp_min;

	float transp_max;

	TBOOL is_shadow;

} CASM_NODE_REFLECTION;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_SHARPEN {

	CASM_UNARY_NODE_HD

	int value;

} CASM_NODE_SHARPEN;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_PREMULTIPLY {

	CASM_UNARY_NODE_HD

} CASM_NODE_PREMULTIPLY;

/*----------------------------------------------------------------------------*/

typedef struct OLD_USR_IMAGE {

	void *buffer;

	enum img_type type;

	int wrap, lx, ly;

	struct {

		LPIXEL *buffer;

		int offset, size;

	} cmap;

} OLD_USR_IMAGE;

typedef struct CASM_NODE_UDIT {

	CASM_N_ARY_NODE_HD

	char *keyword;

	char *op_name;

	char *type;

	int argc;

	char **argv;

	void (*op_function)(OLD_USR_IMAGE *img_in, OLD_USR_IMAGE *img_out, /* only for old udit*/

						int argc, char **argv);

	int plugin_index;

	int fx_index;

} CASM_NODE_UDIT;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_MATTE {

	CASM_BINARY_NODE_HD

	int revert;

} CASM_NODE_MATTE;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_WARP {

	CASM_BINARY_NODE_HD

	int grid_step;

	float intensity;

} CASM_NODE_WARP;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_OVR {

	CASM_BINARY_NODE_HD

} CASM_NODE_OVR;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_BACKLIT {

	CASM_BINARY_NODE_HD

	int diff_values;

	float value;

} CASM_NODE_BACKLIT;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_READ {

	CASM_NODE_HD

	char *filename;

	char *cmapname;

	char *op_name;

	int *no_ink, *no_paint;

	TBOOL keep_inks, keep_paints;

	int premultiply;

	int out_size;

	int argc;

	char **argv;

	void (*op_function)(OLD_USR_IMAGE *img_in,

						OLD_USR_IMAGE *img_out,

						int argc, char **argv);

	enum img_type type;

	int xsize, ysize, border;

	int sbx1, sby1, sbx2, sby2;

	double h_pos;

	UCHAR patch;

	CASM_WINDOW *bg_info;

	int occurrence;

	int full_read;

} CASM_NODE_READ;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_COLOR {

	CASM_UNARY_NODE_HD

	char *keyword;

	int plugin_index;

	int fx_index;

	int num_pars;

	float *pars;

} CASM_NODE_COLOR;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_COLORCARD {

	CASM_NODE_HD

	char *keyword;

	int plugin_index;

	int fx_index;

	int num_pars;

	float *pars;

} CASM_NODE_COLORCARD;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_AFFINE {

	CASM_UNARY_NODE_HD

	AFFINE aff;

	enum CASM_RESAMPLE_TYPE resample_type;

} CASM_NODE_AFFINE;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_S_FLIP {

	CASM_UNARY_NODE_HD

	double c;

} CASM_NODE_S_FLIP;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_EXTOP {

	CASM_UNARY_NODE_HD

	char *op_filename, *format_in, *format_out, *arguments;

} CASM_NODE_EXTOP;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_NO_INK {

	CASM_UNARY_NODE_HD

	int which_ink;

} CASM_NODE_NO_INK;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_UNARY {

	CASM_UNARY_NODE_HD

} CASM_NODE_UNARY;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_BINARY {

	CASM_BINARY_NODE_HD

} CASM_NODE_BINARY;

/*----------------------------------------------------------------------------*/

typedef struct CASM_NODE_N_ARY {

	CASM_N_ARY_NODE_HD

} CASM_NODE_N_ARY;

/*----------------------------------------------------------------------------*/

#endif