/* GODOT ENGINE */

/* https://godotengine.org */

/*************************************************************************/

/* */

/* Permission is hereby granted, free of charge, to any person obtaining */

/* a copy of this software and associated documentation files (the */

#include "core/string/string_name.h"

#include "core/string/ustring.h"

#include "core/templates/list.h"

#include "core/typedefs.h"

#include "core/variant/variant.h"

#ifdef DEBUG_ENABLED

#include "shader_warnings.h"

TK_SEMICOLON,

TK_PERIOD,

TK_UNIFORM,

TK_INSTANCE,

TK_GLOBAL,

TK_VARYING,

TK_ARG_OUT,

TK_ARG_INOUT,

TK_RENDER_MODE,

TK_HINT_NORMAL_TEXTURE,

TK_HINT_ROUGHNESS_NORMAL_TEXTURE,

TK_HINT_ROUGHNESS_R,

TK_HINT_ROUGHNESS_A,

TK_HINT_ROUGHNESS_GRAY,

TK_HINT_ANISOTROPY_TEXTURE,

TK_HINT_RANGE,

TK_HINT_INSTANCE_INDEX,

TK_FILTER_NEAREST,

TK_FILTER_LINEAR,

TK_FILTER_NEAREST_MIPMAP,

TK_FILTER_LINEAR_MIPMAP,

TK_REPEAT_ENABLE,

TK_REPEAT_DISABLE,

TK_SHADER_TYPE,

FILTER_LINEAR,

FILTER_NEAREST_MIPMAP,

FILTER_LINEAR_MIPMAP,

FILTER_DEFAULT,

};

TYPE_CONTROL_FLOW,

TYPE_MEMBER,

TYPE_ARRAY,

TYPE_ARRAY_CONSTRUCT,

TYPE_STRUCT,

};

return node;

}

struct OperatorNode : public Node {

DataType return_cache = TYPE_VOID;

struct Declaration {

StringName name;

};

Vector<Declaration> declarations;

int array_size = 0;

bool is_local = false;

virtual int get_array_size() const override { return (index_expression || call_expression) ? 0 : array_size; }

virtual bool is_indexed() const override { return index_expression != nullptr; }

Node(TYPE_ARRAY_CONSTRUCT) {}

};

struct ConstantNode : public Node {

DataType datatype = TYPE_VOID;

String struct_name = "";

};

Vector<Value> values;

virtual DataType get_datatype() const override { return datatype; }

virtual String get_datatype_name() const override { return struct_name; }

BlockNode *parent_block = nullptr;

enum BlockType {

BLOCK_TYPE_SWITCH,

BLOCK_TYPE_CASE,

BLOCK_TYPE_DEFAULT,

};

SubClassTag block_tag = SubClassTag::TAG_GLOBAL;

struct Variable {

ConstantNode::Value value;

};

List<Node *> statements;

bool single_statement = false;

BlockNode() :

Node(TYPE_BLOCK) {}

Node *call_expression = nullptr;

bool has_swizzling_duplicates = false;

virtual bool is_indexed() const override { return index_expression != nullptr || call_expression != nullptr; }

MemberNode() :

bool is_const;

int array_size;

};

StringName name;

DataType type;

StringName type_str;

DataPrecision precision;

int array_size;

};

struct Function {

StringName name;

bool callable;

};

struct Struct {

StringName name;

};

struct Varying {

struct Uniform {

enum Hint {

HINT_NONE,

HINT_RANGE,

HINT_NORMAL,

HINT_ROUGHNESS_NORMAL,

HINT_ROUGHNESS_R,

HINT_ROUGHNESS_B,

HINT_ROUGHNESS_A,

HINT_ROUGHNESS_GRAY,

HINT_ANISOTROPY,

HINT_MAX

};

Vector<ConstantNode::Value> default_value;

Scope scope = SCOPE_LOCAL;

Hint hint = HINT_NONE;

TextureFilter filter = FILTER_DEFAULT;

TextureRepeat repeat = REPEAT_DEFAULT;

float hint_range[3];

int instance_index = 0;

Uniform() {

hint_range[0] = 0.0f;

}

};

Vector<StringName> render_modes;

Vector<Function> functions;

bool is_op;

union {

Operator op;

};

};

enum CompletionType {

COMPLETION_NONE,

COMPLETION_RENDER_MODE,

COMPLETION_MAIN_FUNCTION,

COMPLETION_IDENTIFIER,

static bool is_token_interpolation(TokenType p_type);

static DataInterpolation get_token_interpolation(TokenType p_type);

static bool is_token_precision(TokenType p_type);

static DataPrecision get_token_precision(TokenType p_type);

static String get_precision_name(DataPrecision p_type);

static String get_datatype_name(DataType p_type);

static bool is_token_nonvoid_datatype(TokenType p_type);

static bool is_token_operator(TokenType p_type);

static bool is_token_operator_assign(TokenType p_type);

static bool is_sampler_type(DataType p_type);

static Variant constant_value_to_variant(const Vector<ShaderLanguage::ConstantNode::Value> &p_value, DataType p_type, int p_array_size, ShaderLanguage::ShaderNode::Uniform::Hint p_hint = ShaderLanguage::ShaderNode::Uniform::HINT_NONE);

static PropertyInfo uniform_to_property_info(const ShaderNode::Uniform &p_uniform);

static void get_keyword_list(List<String> *r_keywords);

static bool is_control_flow_keyword(String p_keyword);

DataType return_type = TYPE_VOID;

};

struct FunctionInfo {

bool can_discard = false;

bool main_function = false;

};

private:

struct KeyWord {

TokenType token;

const char *text;

};

static const KeyWord keyword_list[];

String error_str;

#ifdef DEBUG_ENABLED

struct Usage {

}

};

List<ShaderWarning> warnings;

bool check_warnings = false;

}

}

void _check_warning_accums();

#endif // DEBUG_ENABLED

String code;

StringName current_function;

bool last_const = false;

StringName last_name;

TkPos _get_tkpos() {

TkPos tkp;

error_line = tk_line;

error_set = true;

error_str = p_str;

}

static const char *token_names[TK_MAX];

Token _make_token(TokenType p_type, const StringName &p_text = StringName());

Token _get_token();

enum IdentifierType {

IDENTIFIER_FUNCTION,

};

CompletionType completion_type;

DataType completion_base;

SubClassTag completion_class;

StringName completion_function;

StringName completion_struct;

bool _get_completable_identifier(BlockNode *p_block, CompletionType p_type, StringName &identifier);

static const BuiltinFuncDef builtin_func_defs[];

static bool is_const_suffix_lut_initialized;

bool _compare_datatypes(DataType p_datatype_a, String p_datatype_name_a, int p_array_size_a, DataType p_datatype_b, String p_datatype_name_b, int p_array_size_b);

bool _compare_datatypes_in_nodes(Node *a, Node *b);

bool _propagate_function_call_sampler_uniform_settings(StringName p_name, int p_argument, TextureFilter p_filter, TextureRepeat p_repeat);

bool _propagate_function_call_sampler_builtin_reference(StringName p_name, int p_argument, const StringName &p_builtin);

bool _validate_varying_assign(ShaderNode::Varying &p_varying, String *r_message);

bool _check_node_constness(const Node *p_node) const;

Node *_parse_expression(BlockNode *p_block, const FunctionInfo &p_function_info);

Node *_parse_array_constructor(BlockNode *p_block, const FunctionInfo &p_function_info);

Node *_parse_array_constructor(BlockNode *p_block, const FunctionInfo &p_function_info, DataType p_type, const StringName &p_struct_name, int p_array_size);

ShaderLanguage::Node *_reduce_expression(BlockNode *p_block, ShaderLanguage::Node *p_node);

Node *_parse_and_reduce_expression(BlockNode *p_block, const FunctionInfo &p_function_info);

Error _parse_block(BlockNode *p_block, const FunctionInfo &p_function_info, bool p_just_one = false, bool p_can_break = false, bool p_can_continue = false);

String _get_qualifier_str(ArgumentQualifier p_qualifier) const;

Error _find_last_flow_op_in_block(BlockNode *p_block, FlowOperation p_op);

Error _find_last_flow_op_in_op(ControlFlowNode *p_flow, FlowOperation p_op);

static String get_shader_type(const String &p_code);

struct ShaderCompileInfo {

VaryingFunctionNames varying_function_names = VaryingFunctionNames();

};

Error compile(const String &p_code, const ShaderCompileInfo &p_info);

String get_error_text();

int get_error_line();

ShaderNode *get_shader();