#ifndef STATEMENT_H_29F51659 #define STATEMENT_H_29F51659 #include #include #include #include #include "binding.h" #include "enums.h" #include "field.h" #include "filter.h" namespace verbly { class filter; class order; class statement { public: statement(object context, filter queryFilter); std::string getQueryString(std::list select, order sortOrder, int limit, bool debug = false) const; std::list getBindings() const; private: class join { public: join( bool outer, std::string foreignTableName, std::string joinTable, std::string joinColumn, std::string foreignTable, std::string foreignColumn) : outer_(outer), foreignTableName_(std::move(foreignTableName)), joinTable_(std::move(joinTable)), joinColumn_(std::move(joinColumn)), foreignTable_(std::move(foreignTable)), foreignColumn_(std::move(foreignColumn)) { } bool isOuterJoin() const { return outer_; } const std::string& getForeignTableName() const { return foreignTableName_; } const std::string& getJoinTable() const { return joinTable_; } const std::string& getJoinColumn() const { return joinColumn_; } const std::string& getForeignTable() const { return foreignTable_; } const std::string& getForeignColumn() const { return foreignColumn_; } private: bool outer_ = false; std::string foreignTableName_; std::string joinTable_; std::string joinColumn_; std::string foreignTable_; std::string foreignColumn_; }; friend std::ostream& operator<<(std::ostream& oss, const join& j); class condition { public: enum class type { empty, singleton, group }; enum class comparison { equals, does_not_equal, is_greater_than, is_at_most, is_less_than, is_at_least, is_like, is_not_like, is_not_null, is_null }; // Copy and move constructors condition(const condition& other); condition(condition&& other); // Assignment condition& operator=(condition other); // Swap friend void swap(condition& first, condition& second); // Destructor ~condition(); // Accessors type getType() const { return type_; } // Empty condition(); // Singleton condition(std::string table, std::string column, bool isNull); condition(std::string table, std::string column, comparison comp, binding value); // Group explicit condition(bool orlogic); condition& operator+=(condition n); condition& operator&=(condition n); const std::list& getChildren() const; // Utility std::string toSql(bool toplevel, bool debug = false) const; std::list flattenBindings() const; condition flatten() const; private: union { struct { std::string table_; std::string column_; comparison comparison_; binding value_; } singleton_; struct { std::list children_; bool orlogic_; } group_; }; type type_; }; friend void swap(condition& first, condition& second); class with { public: with( std::string identifier, field f, std::map tables, std::string topTable, condition where, std::list joins, bool recursive) : identifier_(std::move(identifier)), field_(f), tables_(std::move(tables)), topTable_(std::move(topTable)), topCondition_(std::move(where)), joins_(std::move(joins)), recursive_(recursive) { } const std::string& getIdentifier() const { return identifier_; } field getField() const { return field_; } std::string getTableForId(std::string identifier) const { return tables_.at(identifier); } const std::string& getTopTable() const { return topTable_; } const condition& getCondition() const { return topCondition_; } const std::list& getJoins() const { return joins_; } bool isRecursive() const { return recursive_; } private: std::string identifier_; field field_; std::map tables_; std::string topTable_; condition topCondition_; std::list joins_; bool recursive_; }; static constexpr const char* getTableForContext(object context) { return (context == object::notion) ? "notions" : (context == object::word) ? "words" : (context == objec

#version 330 core

in vec2 UV;

out vec3 color;

uniform sampler2D curFrameSampler;
uniform sampler2D NTSCArtifactSampler;
uniform sampler2D prevFrameSampler;

const float Tuning_Sharp = 0.25;
const vec4 Tuning_Persistence = vec4(1.0) * 0.5;
const float Tuning_Bleed = 0.5;
const float Tuning_NTSC = 0.35;
uniform float NTSCLerp;

const vec2 RcpScrWidth = vec2(1.0f / 320.f, 0.0f);
const vec2 RcpScrHeight = vec2(0.0f, 1.0f / 200.0f);

float Brightness(vec4 InVal)
{
  return dot(InVal, vec4(0.299, 0.587, 0.114, 0.0));
}

const float SharpWeight[3] = float[3](1.0, -0.3162277, 0.1);

void main()
{
  vec4 NTSCArtifact1 = texture(NTSCArtifactSampler, UV);
  vec4 NTSCArtifact2 = texture(NTSCArtifactSampler, UV + RcpScrHeight);
  vec4 NTSCArtifact = mix(NTSCArtifact1, NTSCArtifact2, NTSCLerp);
  vec4 TunedNTSC = NTSCArtifact * Tuning_NTSC;
  
  vec2 LeftUV = UV - RcpScrWidth;
  vec2 RightUV = UV + RcpScrWidth;
  
  vec4 Cur_Left = texture(curFrameSampler, LeftUV);
  vec4 Cur_Local = texture(curFrameSampler, UV);
  vec4 Cur_Right = texture(curFrameSampler, RightUV);
  
  vec4 Prev_Left = texture(prevFrameSampler, LeftUV);
  vec4 Prev_Local = texture(prevFrameSampler, UV);
  vec4 Prev_Right = texture(prevFrameSampler, RightUV);
  
  Cur_Local = clamp(Cur_Local + (((Cur_Left - Cur_Local) + (Cur_Right - Cur_Local)) * TunedNTSC), vec4(0,0,0,0), vec4(1,1,1,1));
  
  float curBrt = Brightness(Cur_Local);
  float offset = 0;
  
  for (int i=0; i<3; ++i)
  {
    vec2 StepSize = (RcpScrWidth * float(i+1));
    vec4 neighborleft = texture(curFrameSampler, UV - StepSize);
    vec4 neighborright = texture(curFrameSampler, UV + StepSize);
    
    float NBrtL = Brightness(neighborleft);
    float NBrtR = Brightness(neighborright);
    offset += ((curBrt - NBrtL) + (curBrt - NBrtR)) * SharpWeight[i];
  }
  
  Cur_Local = clamp(Cur_Local + (offset * Tuning_Sharp * mix(vec4(1,1,1,1), NTSCArtifact, Tuning_NTSC)), vec4(0,0,0,0), vec4(1,1,1,1));
  Cur_Local = clamp(max(Cur_Local, Tuning_Persistence * (1.0 / (1.0 + (2.0 * Tuning_Bleed))) * (Prev_Local + ((Prev_Left + Prev_Right) * Tuning_Bleed))), vec4(0,0,0,0), vec4(1,1,1,1));
  
  color = Cur_Local.xyz;
}