🏗 Merge C++ into python codebase (#504)

## Description:

Move esphome-core codebase into esphome (and a bunch of other refactors). See https://github.com/esphome/feature-requests/issues/97

Yes this is a shit ton of work and no there's no way to automate it :( But it will be worth it 👍

Progress:
- Core support (file copy etc): 80%
- Base Abstractions (light, switch): ~50%
- Integrations: ~10%
- Working? Yes, (but only with ported components).

Other refactors:
- Moves all codegen related stuff into a single class: `esphome.codegen` (imported as `cg`)
- Rework coroutine syntax
- Move from `component/platform.py` to `domain/component.py` structure as with HA
- Move all defaults out of C++ and into config validation.
- Remove `make_...` helpers from Application class. Reason: Merge conflicts with every single new integration.
- Pointer Variables are stored globally instead of locally in setup(). Reason: stack size limit.

Future work:
- Rework const.py - Move all `CONF_...` into a conf class (usage `conf.UPDATE_INTERVAL` vs `CONF_UPDATE_INTERVAL`). Reason: Less convoluted import block
- Enable loading from `custom_components` folder.

**Related issue (if applicable):** https://github.com/esphome/feature-requests/issues/97

**Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):** esphome/esphome-docs#<esphome-docs PR number goes here>

## Checklist:
  - [ ] The code change is tested and works locally.
  - [ ] Tests have been added to verify that the new code works (under `tests/` folder).

If user exposed functionality or configuration variables are added/changed:
  - [ ] Documentation added/updated in [esphomedocs](https://github.com/OttoWinter/esphomedocs).

esphome/components/light/light_transformer.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "light_color_values.h"
+
+namespace esphome {
+namespace light {
+
+/// Base-class for all light color transformers, such as transitions or flashes.
+class LightTransformer {
+ public:
+  LightTransformer(uint32_t start_time, uint32_t length, const LightColorValues &start_values,
+                   const LightColorValues &target_values)
+      : start_time_(start_time), length_(length), start_values_(start_values), target_values_(target_values) {}
+
+  LightTransformer() = delete;
+
+  /// Whether this transformation is finished
+  virtual bool is_finished() { return this->get_progress_() >= 1.0f; }
+
+  /// This will be called to get the current values for output.
+  virtual LightColorValues get_values() = 0;
+
+  /// The values that should be reported to the front-end.
+  virtual LightColorValues get_remote_values() { return this->get_target_values_(); }
+
+  /// The values that should be set after this transformation is complete.
+  virtual LightColorValues get_end_values() { return this->get_target_values_(); }
+
+  virtual bool publish_at_end() = 0;
+
+ protected:
+  /// Get the completion of this transformer, 0 to 1.
+  float get_progress_() { return clamp((millis() - this->start_time_) / float(this->length_), 0.0f, 1.0f); }
+
+  const LightColorValues &get_start_values_() const { return this->start_values_; }
+
+  const LightColorValues &get_target_values_() const { return this->target_values_; }
+
+  uint32_t start_time_;
+  uint32_t length_;
+  LightColorValues start_values_;
+  LightColorValues target_values_;
+};
+
+class LightTransitionTransformer : public LightTransformer {
+ public:
+  LightTransitionTransformer(uint32_t start_time, uint32_t length, const LightColorValues &start_values,
+                             const LightColorValues &target_values)
+      : LightTransformer(start_time, length, start_values, target_values) {
+    // When turning light on from off state, use colors from new.
+    if (!this->start_values_.is_on() && this->target_values_.is_on()) {
+      this->start_values_.set_brightness(0.0f);
+      this->start_values_.set_red(target_values.get_red());
+      this->start_values_.set_green(target_values.get_green());
+      this->start_values_.set_blue(target_values.get_blue());
+      this->start_values_.set_white(target_values.get_white());
+      this->start_values_.set_color_temperature(target_values.get_color_temperature());
+    }
+  }
+
+  LightColorValues get_values() override {
+    float x = this->get_progress_();
+    float v = x * x * x * (x * (x * 6.0f - 15.0f) + 10.0f);
+    return LightColorValues::lerp(this->get_start_values_(), this->get_target_values_(), v);
+  }
+
+  bool publish_at_end() override { return false; }
+};
+
+class LightFlashTransformer : public LightTransformer {
+ public:
+  LightFlashTransformer(uint32_t start_time, uint32_t length, const LightColorValues &start_values,
+                        const LightColorValues &target_values)
+      : LightTransformer(start_time, length, start_values, target_values) {}
+
+  LightColorValues get_values() override { return this->get_target_values_(); }
+
+  LightColorValues get_end_values() override { return this->get_start_values_(); }
+
+  bool publish_at_end() override { return true; }
+};
+
+}  // namespace light
+}  // namespace esphome