blending modes are loaded modularly now

effects/add.blend

@@ -0,0 +1,13 @@
+float blendAdd(float base, float blend) {
+	return min(base+blend,1.0);
+}
+
+vec3 blendAdd(vec3 base, vec3 blend) {
+	return min(base+blend,vec3(1.0));
+}
+
+vec3 blendAdd(vec3 base, vec3 blend, float opacity) {
+	return (blendAdd(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendAdd)

effects/average.blend

@@ -0,0 +1,9 @@
+vec3 blendAverage(vec3 base, vec3 blend) {
+	return (base+blend)/2.0;
+}
+
+vec3 blendAverage(vec3 base, vec3 blend, float opacity) {
+	return (blendAverage(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendAverage)

effects/color-burn.blend

@@ -0,0 +1,13 @@
+float blendColorBurn(float base, float blend) {
+	return (blend==0.0)?blend:max((1.0-((1.0-base)/blend)),0.0);
+}
+
+vec3 blendColorBurn(vec3 base, vec3 blend) {
+	return vec3(blendColorBurn(base.r,blend.r),blendColorBurn(base.g,blend.g),blendColorBurn(base.b,blend.b));
+}
+
+vec3 blendColorBurn(vec3 base, vec3 blend, float opacity) {
+	return (blendColorBurn(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendColorBurn)

effects/color-dodge.blend

@@ -0,0 +1,13 @@
+float blendColorDodge(float base, float blend) {
+	return (blend==1.0)?blend:min(base/(1.0-blend),1.0);
+}
+
+vec3 blendColorDodge(vec3 base, vec3 blend) {
+	return vec3(blendColorDodge(base.r,blend.r),blendColorDodge(base.g,blend.g),blendColorDodge(base.b,blend.b));
+}
+
+vec3 blendColorDodge(vec3 base, vec3 blend, float opacity) {
+	return (blendColorDodge(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendColorDodge)

effects/darken.blend

@@ -0,0 +1,13 @@
+float blendDarken(float base, float blend) {
+	return min(blend,base);
+}
+
+vec3 blendDarken(vec3 base, vec3 blend) {
+	return vec3(blendDarken(base.r,blend.r),blendDarken(base.g,blend.g),blendDarken(base.b,blend.b));
+}
+
+vec3 blendDarken(vec3 base, vec3 blend, float opacity) {
+	return (blendDarken(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendDarken)

effects/difference.blend

@@ -0,0 +1,9 @@
+vec3 blendDifference(vec3 base, vec3 blend) {
+	return abs(base-blend);
+}
+
+vec3 blendDifference(vec3 base, vec3 blend, float opacity) {
+	return (blendDifference(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendDifference)

effects/exclusion.blend

@@ -0,0 +1,9 @@
+vec3 blendExclusion(vec3 base, vec3 blend) {
+	return base+blend-2.0*base*blend;
+}
+
+vec3 blendExclusion(vec3 base, vec3 blend, float opacity) {
+	return (blendExclusion(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendExclusion)

effects/glow.blend

@@ -0,0 +1,11 @@
+#pragma glslify: blendReflect = require(./reflect)
+
+vec3 blendGlow(vec3 base, vec3 blend) {
+	return blendReflect(blend,base);
+}
+
+vec3 blendGlow(vec3 base, vec3 blend, float opacity) {
+	return (blendGlow(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendGlow)

effects/hard-light.blend

@@ -0,0 +1,11 @@
+#pragma glslify: blendOverlay = require(./overlay)
+
+vec3 blendHardLight(vec3 base, vec3 blend) {
+	return blendOverlay(blend,base);
+}
+
+vec3 blendHardLight(vec3 base, vec3 blend, float opacity) {
+	return (blendHardLight(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendHardLight)

effects/hard-mix.blend

@@ -0,0 +1,15 @@
+#pragma glslify: blendVividLight = require(./vivid-light)
+
+float blendHardMix(float base, float blend) {
+	return (blendVividLight(base,blend)<0.5)?0.0:1.0;
+}
+
+vec3 blendHardMix(vec3 base, vec3 blend) {
+	return vec3(blendHardMix(base.r,blend.r),blendHardMix(base.g,blend.g),blendHardMix(base.b,blend.b));
+}
+
+vec3 blendHardMix(vec3 base, vec3 blend, float opacity) {
+	return (blendHardMix(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendHardMix)

effects/internal/transformeffect.cpp

@@ -36,6 +36,7 @@
 #include "io/math.h"
 #include "ui/labelslider.h"
 #include "ui/comboboxex.h"
+#include "project/effectloaders.h"
 #include "panels/project.h"
 #include "debug.h"
 
@@ -78,9 +79,11 @@ TransformEffect::TransformEffect(Clip* c, const EffectMeta* em) : Effect(c, em)
   blend_mode_box->add_combo_item(tr("Normal"), -1);
 
   // add loaded blending modes
+  olive::effects_loaded.lock();
   for (int i=0;i<olive::blend_modes.size();i++) {
     blend_mode_box->add_combo_item(olive::blend_modes.at(i).name, i);
   }
+  olive::effects_loaded.unlock();
 
   // set up gizmos
   top_left_gizmo = add_gizmo(GIZMO_TYPE_DOT);

effects/lighten.blend

@@ -0,0 +1,13 @@
+float blendLighten(float base, float blend) {
+	return max(blend,base);
+}
+
+vec3 blendLighten(vec3 base, vec3 blend) {
+	return vec3(blendLighten(base.r,blend.r),blendLighten(base.g,blend.g),blendLighten(base.b,blend.b));
+}
+
+vec3 blendLighten(vec3 base, vec3 blend, float opacity) {
+	return (blendLighten(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendLighten)

effects/linear-burn.blend

@@ -0,0 +1,15 @@
+float blendLinearBurn(float base, float blend) {
+	// Note : Same implementation as BlendSubtractf
+	return max(base+blend-1.0,0.0);
+}
+
+vec3 blendLinearBurn(vec3 base, vec3 blend) {
+	// Note : Same implementation as BlendSubtract
+	return max(base+blend-vec3(1.0),vec3(0.0));
+}
+
+vec3 blendLinearBurn(vec3 base, vec3 blend, float opacity) {
+	return (blendLinearBurn(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendLinearBurn)

effects/linear-dodge.blend

@@ -0,0 +1,15 @@
+float blendLinearDodge(float base, float blend) {
+	// Note : Same implementation as BlendAddf
+	return min(base+blend,1.0);
+}
+
+vec3 blendLinearDodge(vec3 base, vec3 blend) {
+	// Note : Same implementation as BlendAdd
+	return min(base+blend,vec3(1.0));
+}
+
+vec3 blendLinearDodge(vec3 base, vec3 blend, float opacity) {
+	return (blendLinearDodge(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendLinearDodge)

effects/linear-light.blend

@@ -0,0 +1,16 @@
+#pragma glslify: blendLinearDodge = require(./linear-dodge)
+#pragma glslify: blendLinearBurn = require(./linear-burn)
+
+float blendLinearLight(float base, float blend) {
+	return blend<0.5?blendLinearBurn(base,(2.0*blend)):blendLinearDodge(base,(2.0*(blend-0.5)));
+}
+
+vec3 blendLinearLight(vec3 base, vec3 blend) {
+	return vec3(blendLinearLight(base.r,blend.r),blendLinearLight(base.g,blend.g),blendLinearLight(base.b,blend.b));
+}
+
+vec3 blendLinearLight(vec3 base, vec3 blend, float opacity) {
+	return (blendLinearLight(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendLinearLight)

effects/negation.blend

@@ -0,0 +1,9 @@
+vec3 blendNegation(vec3 base, vec3 blend) {
+	return vec3(1.0)-abs(vec3(1.0)-base-blend);
+}
+
+vec3 blendNegation(vec3 base, vec3 blend, float opacity) {
+	return (blendNegation(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendNegation)

effects/normal.blend

@@ -0,0 +1,9 @@
+vec3 blendNormal(vec3 base, vec3 blend) {
+	return blend;
+}
+
+vec3 blendNormal(vec3 base, vec3 blend, float opacity) {
+	return (blendNormal(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendNormal)

effects/overlay.blend

@@ -0,0 +1,13 @@
+float blendOverlay(float base, float blend) {
+	return base<0.5?(2.0*base*blend):(1.0-2.0*(1.0-base)*(1.0-blend));
+}
+
+vec3 blendOverlay(vec3 base, vec3 blend) {
+	return vec3(blendOverlay(base.r,blend.r),blendOverlay(base.g,blend.g),blendOverlay(base.b,blend.b));
+}
+
+vec3 blendOverlay(vec3 base, vec3 blend, float opacity) {
+	return (blendOverlay(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendOverlay)

effects/phoenix.blend

@@ -0,0 +1,9 @@
+vec3 blendPhoenix(vec3 base, vec3 blend) {
+	return min(base,blend)-max(base,blend)+vec3(1.0);
+}
+
+vec3 blendPhoenix(vec3 base, vec3 blend, float opacity) {
+	return (blendPhoenix(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendPhoenix)

effects/pin-light.blend

@@ -0,0 +1,16 @@
+#pragma glslify: blendLighten = require(./lighten)
+#pragma glslify: blendDarken = require(./darken)
+
+float blendPinLight(float base, float blend) {
+	return (blend<0.5)?blendDarken(base,(2.0*blend)):blendLighten(base,(2.0*(blend-0.5)));
+}
+
+vec3 blendPinLight(vec3 base, vec3 blend) {
+	return vec3(blendPinLight(base.r,blend.r),blendPinLight(base.g,blend.g),blendPinLight(base.b,blend.b));
+}
+
+vec3 blendPinLight(vec3 base, vec3 blend, float opacity) {
+	return (blendPinLight(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendPinLight)

effects/reflect.blend

@@ -0,0 +1,13 @@
+float blendReflect(float base, float blend) {
+	return (blend==1.0)?blend:min(base*base/(1.0-blend),1.0);
+}
+
+vec3 blendReflect(vec3 base, vec3 blend) {
+	return vec3(blendReflect(base.r,blend.r),blendReflect(base.g,blend.g),blendReflect(base.b,blend.b));
+}
+
+vec3 blendReflect(vec3 base, vec3 blend, float opacity) {
+	return (blendReflect(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendReflect)

effects/screen.blend

@@ -0,0 +1,13 @@
+float blendScreen(float base, float blend) {
+	return 1.0-((1.0-base)*(1.0-blend));
+}
+
+vec3 blendScreen(vec3 base, vec3 blend) {
+	return vec3(blendScreen(base.r,blend.r),blendScreen(base.g,blend.g),blendScreen(base.b,blend.b));
+}
+
+vec3 blendScreen(vec3 base, vec3 blend, float opacity) {
+	return (blendScreen(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendScreen)

effects/soft-light.blend

@@ -0,0 +1,13 @@
+float blendSoftLight(float base, float blend) {
+	return (blend<0.5)?(2.0*base*blend+base*base*(1.0-2.0*blend)):(sqrt(base)*(2.0*blend-1.0)+2.0*base*(1.0-blend));
+}
+
+vec3 blendSoftLight(vec3 base, vec3 blend) {
+	return vec3(blendSoftLight(base.r,blend.r),blendSoftLight(base.g,blend.g),blendSoftLight(base.b,blend.b));
+}
+
+vec3 blendSoftLight(vec3 base, vec3 blend, float opacity) {
+	return (blendSoftLight(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendSoftLight)

effects/substract.blend

@@ -0,0 +1,13 @@
+float blendSubstract(float base, float blend) {
+	return max(base+blend-1.0,0.0);
+}
+
+vec3 blendSubstract(vec3 base, vec3 blend) {
+	return max(base+blend-vec3(1.0),vec3(0.0));
+}
+
+vec3 blendSubstract(vec3 base, vec3 blend, float opacity) {
+	return (blendSubstract(base, blend) * opacity + blend * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendSubstract)

effects/subtract.blend

@@ -0,0 +1,13 @@
+float blendSubtract(float base, float blend) {
+	return max(base+blend-1.0,0.0);
+}
+
+vec3 blendSubtract(vec3 base, vec3 blend) {
+	return max(base+blend-vec3(1.0),vec3(0.0));
+}
+
+vec3 blendSubtract(vec3 base, vec3 blend, float opacity) {
+	return (blendSubtract(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendSubtract)

effects/vivid-light.blend

@@ -0,0 +1,16 @@
+#pragma glslify: blendColorDodge = require(./color-dodge)
+#pragma glslify: blendColorBurn = require(./color-burn)
+
+float blendVividLight(float base, float blend) {
+	return (blend<0.5)?blendColorBurn(base,(2.0*blend)):blendColorDodge(base,(2.0*(blend-0.5)));
+}
+
+vec3 blendVividLight(vec3 base, vec3 blend) {
+	return vec3(blendVividLight(base.r,blend.r),blendVividLight(base.g,blend.g),blendVividLight(base.b,blend.b));
+}
+
+vec3 blendVividLight(vec3 base, vec3 blend, float opacity) {
+	return (blendVividLight(base, blend) * opacity + base * (1.0 - opacity));
+}
+
+#pragma glslify: export(blendVividLight)