005 EU Meetup September 25, 2017

Jean, Jim and Juan,

Another great meetup last week.

Just want to again extend the invitation for the meeting tomorrow.
Skype meetup on
Monday: September 25, 2017 at
UTC-3      8:00pm
Mountain  5:00pm
PST          4:00pm

Notes from last week:

Ignacio Cisneros
Medical Practice – Sound Current – Jokn of God
Edgar Cayce
Sphinx Predates Pyramids
Jim Fibrations
Carbon Dating – Chris Reeve – Emails –  Wal Thornberg
DBD – Radiometric Dating – Gradualism – Evolution – Creationism – Uniformitarianism –
Philosophy of Science – Deterministic – Nature of Matter – plasma – experiments –
Causality – Conservation – Scales – Interconnection – Infinite Universe Theory –
Plasma – Perats – Plasma Blue Whirl Filaments – Discharge – 2005 EU Book –

 

Unbroken chain of comparison – measuring time – distance – sol – Red Shift – Arcturus – Motion across the sky if not as far away as we think
Parallax- distance – shells of material – refractive index – Paralax space velocity – Normal velocity – moving motion matched – Arcturus
Red Giants – Orders of magnitude difference – Red shift – index of refraction – non linear variance
Time independence – Current Density – Edward D.  Double Layer – Ionization Fronts

Michael Clarage   – CPAK – Sol – Spirit – Bessel Function Filaments
Pole star associated with Saturn – Hamlets Mill – Dwardu Cardona  – Gods Fire = Filamentary Gas Clouds
Time Line – Jean:
Period – 27,000 events – 11,000 BC
Venus 35,000 BC – Venus Figures – Michelin Man – Saturn coming in at an angle
11,000 BC North American – Double layer Breach – 1000 years of darkness and extreme cold – Robert Shock
Jerginson Breach Compression Force – Repulsive Force – Arc – Jergins – Electic Field Force – Time Line
35 species of
Clavas Points
Petra Glyphs 8000 – Back to Ocean – Current
Pale Inc – Chinese – Coming over in Boats –
Chrsanthemum and the Sword – Japanese Culture –
After 1000
Hipso Paleozoic – Green Sahara – Earth Spiraling Down – Glowing Plasma – Earth would end up can see
Gods are seen – 4,000 – Golden Era – See Saturn – Unversal Goddess – Gaia – Dragon – Vesica Pisces
300ad – Mary Magdalene – Peter, Paul
🙂
/dj

David W. Johnson <dj@argos.vu>

Sep 25

to jhafnerJimJuan
Guys,
Here is the pdf that I ran across before the meeting today:
From this guy: Dan Winter – Buddy Dougherty – suggested to check him out.
🙂
/dj

David W. Johnson <dj@argos.vu>

Sep 27

to jhafnerJimJuan

Greetings all,

This site is probably worth a perusal.
I run across a lot of material from this character on twitter:


004 EU Meetup September 18, 2017

Jean, Jim and Juan,

Great meetup again last week.

Just want to again extend the invitation for the meeting tomorrow.
Skype meetup on
Monday: September 18, 2017 at
UTC-3      8:00pm
Mountain  5:00pm
PST          4:00pm
Here are some notes with some links for reference from last week 🙂
Newton
Alcyone Central Sun
Materialism
Michelson Morely – Light Speed – Measure motion throught ether
Material moves with environment
Externsteine
Cycles of Time
Hamlets Mill – Holy Science
Take them Back in Time – CPAK – Experts – World view Walter Cruttenden
Precession – East Myths – Ideas – Sun is orbiting another – CPAK Robert Shock – Sphinxs – John Anthony West
Dynasty in Egypt
Recent Catastrophies – Conflict – Dynamic – Impulse
Ancient people knew – Trace them out over time – Catostrophic changes – Ring – Impulse – Precession = 90*
Holy Science … Wake up and Go to Sleep – Darkest Ages – Senses – WitchCraft – Electic Forces Magnetic Forces –
As Above so Below – MicroWaves – xRays –
All branches should converge – Multidisciplinary
Dave Talbot = Core Mythology – Ancient Sources – no isolated source – Aztecs reconstruction
sky theater arc mode plasma – stark mars – venus – Arians – stringy things Cometary Shape – Mars – Evidence
Ev Cochrane: Planetary Catastrophe
Venus Plasma Tail – Point Like a Cris Reeve – Thermal non Equilibrium – GeMerkin – Good Speed
Space News Velikovskian Double Layers Worlds in Collision
Taurus = Ancient Sky – Piedes on the Shoulder – Lascaux Cave – Depiction
 evidence – cosmic mountain – spiral – Yadrisil – Bull circle between the Horns
Jupiter – in the Picture – Archetypes – Journals – Reconstruction



Sep 22
to jhafnerJimJuan

Hey guys,

Ran across this info through Don Mitchel.

Thought it might contribute to the conversation.

🙂

/dj

the.Vu

———- Forwarded message ———-
From: David W. Johnson <dj@argos.vu>
Date: Fri, Sep 22, 2017 at 10:15 AM
Subject: Bergson’s Holographic Theory – 18 – Tesla and the Ether
To: don mitchell <don86326@gmail.com>

Ran across this last night,

Interested in your take on it:

Bergson’s Holographic Theory – 18 – Tesla and the Ether

https://youtu.be/3OANm6DtFc8

http://www.stephenerobbins.com/

the.Vu

On Fri, Sep 22, 2017 at 9:54 AM, don mitchell <don86326@gmail.com> wrote:

Join the resistance (humor)

http://i.imgur.com/vyk9AU5.jpg

On Fri, Sep 22, 2017 at 9:33 AM, don mitchell <don86326@gmail.com> wrote:

Hi David,

Thanks for the post-chat email with links about our talk.  That helps my neurons.  The tree of dodecadhedral twins is fascinating, looking graphically similar to x-ray diffraction patterns through crystals.  Thanks for the gimbling illustrations.

I thought you may appreciate the speculation by Neil below on a density-increase of the local aether within our solar system, which he cites as evident by a now permanent halo around the moon.

His long-time site is http://worlds-within-worlds.org/.

Neil is a sensitive (as in telepathic-ish) trained by an American Indian shawoman (lady shaman). I’ve never met him in person or talked to him.  We’ve traded emails over the years, and he keeps me on at least some of his mailings as a BCC recipient, usually.  I think his mathematical physics centers around Russian spinor theory (aether matrix), and claims to have the proper answer.  He is degreed in computer science.

cheers – don

———- Forwarded message ———-
From: Robert Neil Boyd Ph D <rnboydphd@comcast.net>
Date: Fri, Sep 22, 2017 at 6:47 AM
Subject: The Sun is now radiating Rainbow Lights
To: “David G. Yurth” <davidyurth@comcast.net>, “Dr Jon ‘Xue Zhang’ Jang Ph.D” <xueskill69@gmail.com>, “Dr. Adrian Klein” <adrian10@bezeqint.net>, “Dr. Sergey N. Arteha,” <sergey.arteha@gmail.com>, Florentin Smarandache <fsmarandache@gmail.com>, “Frank Demuro, CEO, PBTC” <pbtc@verizon.net>, Gene Nassoiy Barbour <gene@nassoiy.com>, Helmut Hansen <helmuthansen@gmx.de>, Huping Hu <editor@prespacetime.com>, Ivars Fabriciuss <ivars.fabriciuss@gmail.com>, “Ji Hao,” <wujihao@mail.ipc.ac.cn>, Luca Bianchi <luca.bianchi@infinito.it>, Louis Malklaka <malklaka2012@gmail.com>, Pierre-Marie Robitaille <robitaille.1@osu.edu>, “Prof. Andre K. T. Assis,” <assis@ifi.unicamp.br>, “Prof. Stephan J. G. Gift” <stephan.gift@sta.uwi.edu>, “Prof. Zifeng Li” <zfli@ysu.edu.cn>, Volodymyr Krasnoholovets <subhydrogen@gmail.com>, Wallace Thornhill <walt@holoscience.com>
Cc: Bialek Szczepan <sz.bialek@wp.pl>, Bonny Willow <me@bonniewillow.com>, Byoung Ha Ahn <bahn1@comcast.net>, d.j.bierman@uva.nl, Daniel Hirsch <danielhhirsch@gmail.com>, DonEMitchell <don86326@gmail.com>, “Dr. Angelo A Toriello” <drtoriello@gmail.com>, “Dr. Edward Henry Dowdye, Jr.” <gravityfindings@gmail.com>, “Dr. Neal Graneau” <neal.graneau@googlemail.com>, Francesca Intini <intini@fisica.uniba.it>, Greg Volk <the.volks@comcast.net>, Hu Chang-Wei <huchangwei@sina.cn>, Jean Wood Gupta <jeangupta_785@hotmail.com>, Jesse Going <jblaiseg@gmail.com>, Quique Barletta <qbarletta@sbcglobal.net>, Wendy Zammit <wendyzammit@gmail.com>

If you will look at a smooth reflective surface with some curvature to it and catch the reflection of the sun at the proper angle, you will easily see movingrainbow “spikes” which are radiating from and involved with the sun.

This is a new phenomenon and is directly related to direct and recorded observations of the years-long rainbow ring around the full moon and the rainbow rings around all manner of human-made light fixtures, in my opinion. These are not the intermittent rainbow rings from decades past, but PERMANENT and globally observable rainbow rings. The ring around the moon is always there now, and this is not at all the rare event it used to be 50 to 100 years ago.

Notice the spikes of light radiating from the central moon circle. I think these are directly connected to the properties of the sunlight that the moon is reflecting to us.

I think these newly observed rainbow sun-spikes are due the same kind of aether density increase which has been causing lunar rainbow rings, intensifying in its influence so that now the effect is directly observable in sun-reflections. I am of the opinion that these rainbow lights are due to increased aether density associated with shells of increased aether density which every galaxy throws off periodically in events known as quantized red shifts.

Due to astrophysical observations of the periodicity of galactic quantized red shifts, I predicted several years ago that the fine structure constant would be changing in value in the future, and indeed it has been changing in its measured value for several years. As the fine structure constant is changing, so too are the fundamental laws of physics are changing.

When the shell of increased aether density has passed entirely through the solar system, at the other side of the shell, the laws of physics will be observed to have been altered permanently in our vicinity in the galaxy.

As I have said before, there are no constants. There are only locally reliable average values which are not long-lived in their purview. Experiment has proved that Planck’s “constant” is not a constant. The force due to gravitation is not a constant. The speed of light is not a constant. And so on and so forth.

We may make measurements with our instrumentations but we should not expect the observed values of any of the “constants” to be reliable for any projects which require long term precision of the measured values of the various constants. In the short term, the currently measured values of the “constants” are usable in most practical applications, but cannot be expected to hold up, long term.

In concert with all these rainbows involved with all light sources, there is an equally irresistible increase in Harmony and Unity Consciousness factors which is directly influencing all life, human beings included.

It is blatantly obvious that these processes cannot be stopped, and that they will not stop. They are Galactic in scale, and Divinely Caused, in my view.

Best Wishes,

Neil

003 EU Meetup September 11, 2017

Jean, Jim and Juan,

Great conversation again last week.

Just want to again extend the invitation for the meeting tomorrow.

Skype meetup on

Monday: September 11, 2017 at

UTC-3      8:00pm

Mountain  5:00pm

PST          4:00pm

I have some scratch notes and some interesting back and forths from last week:

Here are notes with some links for reference and perusal 🙂

—————————————

the Kybalion

http://www.kybalion.org/kybalion.php

7 principles from which the universe works

all is one

equivalence – as above so below

—————————————

Ebner Effect PhenoType – 1000 volts per centemeter

http://www.rexresearch.com/ebner/ebner.htm

http://aetherforce.com/ebner-effect-altering-genetic-expression-with-electroculture/

—————————————

Jim Murray Paul Babcock

https://www.activistpost.com/2015/12/we-interviewed-the-man-who-claims-to-have-saved-nikola-teslas-secrets.html

https://energyscienceconference.com/

tesla = provide testimony explain – magnifying effective power – nested resonances – Reactive Watts – Lent to the system – Jim Murray and Paul Babcock

https://youtu.be/YhaAxQjyeC0

—————————————

Gods Fire

Moses and the

Management of Exodus

by

Alfred de Grazia

http://bearfabrique.org/History/gf_docs/gf_1.pdf

—————————————

Etruscians

https://www.google.com/search?q=etruscans&source=lnms&tbm=isch&sa=X&ved=0ahUKEwjYqbjL7ZvWAhXrilQKHTsGCkwQ_AUICigB&biw=1536&bih=724

—————————————

Irving Wolf – 1994 Velacofski symposium

https://www.thunderbolts.info/wp/2017/02/01/big-and-little-science/

—————————————

Book Limitation of Thinking – Andy Fitz – EU Duard – Breakout Adam Stewart –

Jadowsky = Row Boat – Peculiar – Done Research –

extinctions Nemesis Star – 26,000 — Up and Down throught the plane of the galaxy – Longer Term Schedule – Catastrophic – Crunden – Long Term Cycles Local Circuitry;

Everything Duardo – Judeo Christian – Catholic Replacement – Moluch – Elohim – Central Chimney – Sheldrake ESP – Andrew Edwins – Clarence King – USGS – Catastrophist

Miles Hutton – Uniformitarian. Louise Agascy… Races created separately. Steven J Gould writer evolution – eugenics –

https://jacobinmag.com/2017/05/stephen-jay-gould-science-race-evolution-climate-change

—————————————

There was some back and forth discussions

mainstream error in electrodynamics:

From Juan:

The Universe is an intrinsically unified physically extended compressible material substrate, a contiguum with no empty spaces anywhere. The Universe is not “filled with” matter, it is matter and nothing else. You, me and all things are just finite modifications formed from and embedded in such an infinite substance. Temporary waves in the eternal Ocean.

Principles of Light and Color:

https://archive.org/details/PrinciplesOfLightAndColor

from 1878 Edwin D. Babbit

Eric Dollard mentioned it in this interview:

https://youtu.be/DjbxTdcWBQI

Looking forward to the meeting.

🙂

/dj

ps: Thought this atomic idea had some helices within helices resonances:

Any topics you’d like to cover I can collate so we can reference them during the meeting.

Have a great Sunday.

🙂

/dj

David W. Johnson <dj@argos.vu>

AttachmentsSep 12

to Jim

That’s funny,

I was perusing “God’s Fire” this morning…
🙂
/dj

 

On Tue, Sep 12, 2017 at 8:20 AM, Jim Weninger <jwen1@yahoo.com> wrote:

I’ve been reading again “God Star”, and Dwardu definitely had the correlation right, when talking of the sun’s position relative to Taurus and the Pleiades,  as being used to mark calendars in ancient times. This is still a tool used by some cultures to mark calendars (the position of the sun relative to the constelation).  Then he says also very correctly, “If this turns out to be correct, the association of the Pleiades with this planetary deity requires an explanation since this constellation has no observable connection with the planet Saturn”.
   So, we have records from ancient times that used the sun in Taurus to mark the calendar, we have cultures in modern times that do the same, and a seeming continuous use in between.  Note of course that with precession, the sun’s position drifts over time. Yet when we see a culture that depicts the sun between the horns of the bull, and can trace that culture back to a time when sure enough, that postion of the sun (that’s our current sun to be sure!) between the horns does match their “time”, we still are going to make this about Saturn?  
    Again, if this bull with star/planet between its horns came down to us without context, we could make it about Saturn, or anything we wanted.  But the context has always been the same. Ancient peoples as far back as we can trace, (and some still now), use the sun’s position relative to the constellation, to distinguish not only where they are in the year, but where their year is in time compared to other years.  
   Once again, I’m not denying the polar configuration, or Saturn’s position in it. Just that not ALL the mythology handed down to us comes from this one time, or this one event.  Basically, all cultures around the world, were aware of precession, and that the sun’s position relative to background constellations was the only way to keep track of longer term cycles. This was common knowledge around the world until the idea was accepted that the world was created  mere thousands of years ago.  No reason to track where the sun is in the precessional cycle, if the whole universe was not around long enough for even half of one cycle.      
           
 
 
rom: Juan Calsiano <juancalsiano@gmail.com>
To: Jim Weninger <jwen1@yahoo.com>
Cc: “dj@argos.vu” <dj@argos.vu>; jhafner <jhafner@swcp.com>
Sent: Monday, September 11, 2017 10:01 PM
Subject: Re: Taurus History

Hi Jim and all!

That Taurus was first identified as the Bull of Heaven (and not the other way around!) in “Babylonian times” could very well be the case, at least in principle. This doesn’t mean that the Bull of Heaven global archetype was generated at such times, of course.

Actually, all of the archetypes (the seemingly outrageous global agreements) are clearly prehistoric, i.e. they reflect memorialized events before the rise of (at least what we understand to be) the first civilizations like the Babylonians. And the Bull of Heaven is one of these archetypes of course, so this would be consistent with the position of all the mytho-historical scholars that argue that the associations of archetypes with constellations came after the proto-planetary deities left the main stage (so to speak).
That is, the Bull of Heaven archetype, the Sun God archetype and the intimate connection between these two archetypes were all generated before the association to constellations, an association that absolutely did happen but after the original stimulus (the theater in the sky) was not longer there. Or so is the argument.

Again, in order to reconstruct what actually happened we need very reliable data. Nothing less than that will suffice. In order to extract reliable data from obviously unreliable witnesses, we may learn from forensics the golden rule of prehistorical reconstruction:

“All isolated ancient sources are absolutely unreliable by themselves. Reliable conclusions can only arise from a detailed convergence of global testimony that would otherwise be impossible to exist in the absence of a shared extraordinary natural experience”. 
The reliable data points that any reasonably scientific reconstruction must include are the “archetypes”, the very detailed yet completely outrageous global patterns. There are hundreds of archetypes, most of them identified by many “mainstream” scholars before Velikovsky and his followers, and not a single of those patterns are understandable in terms of our current skies. Not one of them. Yet each and every one must have an explanation.

A few of the mysterious global archetypes are:
1) The Bull of Heaven
2) The God / Goddess with Outstretched Arms
3) Twin Peaks of the World
4) The Cosmic Pillar
5) The Cosmic Mountain
6) The Ship of Heaven
7) The Ship of Day and Night
8) The Inverted Ship of Night
9) The Heavenly Twins
10) The Separation of the Heaven and Earth
11) The “Beginning” of Time
Etc.

There are many many other global patterns, like the Serpent / Dragon, the Mother Goddess, the Warrior / Hero, each of the distinct characteristics of the Warrior Hero (the swelling god, god of the underworld, the scarred god, the pupil of the eye), etc.
All of these global agreements must be data points in any scientific reconstruction worth their salt. It is the reliable mytho-historical evidence that absolutely makes no sense, but must make sense.
But the most fascinating thing is that all these data points are interconnected! The ancient sources demonstrate that the bull of heaven is inseparably connected to the outstretched arms, the twin peaks of the world, the cosmic pillar, etc.
In my humble opinion, the unparalleled strength of Dave’s Talbott (and others) argument is that if you postulate just one particular seemingly outrageous configuration in the sky, it seems that you can deduce or “retrodict” most if not all of these global patterns! Even more, many of the interconnections between the different archetypes seem to make immediate sense just by following the physical demands of the hypothesis.

To see how the eleven archetypes that I mentioned above are retrodicted from the so-called “polar configuration”, and more importantly, to see how they interconnect, you can review Discourses of an Alien Sky, from #11 to #23. Here is my youtube playlist, which I actually recommend watching in full:

https://www.youtube.com/watch?v=nw_YoinTgfc&list=PLKlF2aI12kTYNfpueHT00OSMOQJ0T-n3I&index=22

Of course, the video is just a quick glimpse of the vast library of mytho-historical-symbolical evidence available. If any anyone wants to get serious, there are voluminous publications discussing this with much greater detail.
So we have this PC idea that seemingly explains very simply a big part of the hundreds of universal agreements between the ancient cultures and is seemingly supported by increasing amounts of evidence from the hard sciences, like for example what I mentioned today regarding Venus, Mars, comets being pieces of planets excavated by the “thunderbolts of the gods”, etc.
If you are challenging the proto-planetary basis of the reconstruction (for example, when claiming that The Bull of Heaven archetype has nothing to do with planets), then you have the burden of at least showing how all those archetypes (and Venus as Mother Goddess, Mars as Warrior / Hero, etc.), all of which are global patternsthat seem to be easily explained by the PC hypothesis, could be also explained by a completely different hypothesis / model where extra-solar stars such as Taurus are the gods (remember that the bull of heaven was a deity).
And this is actually only a relatively minute part of the whole colossal burden, as I briefly tried to explain in my previous email, e.g. if we humans were here for so long and with very high levels of sophistication, where’s the overwhelming evidence from all the branches of science converging to such a very radical proposal?

Again, I am not an expert by any means, so please do not believe me! Anyway, I need to focus on my thing… This topic is too exciting for me, please stop! LOL 

I’m currently studying Collective Electrodynamics by one of my heroes, Carver Mead. If you want to switch a bit into Physics, I highly recommend watching this lecture:

https://www.youtube.com/watch?v=CnwX2IF46m0

It was great speaking with you guys today, have a good night!

Cheers,
Juan

 

On 12 September 2017 at 01:37, Jim Weninger <jwen1@yahoo.com> wrote:

I should have just posted a picture:
Note the ecliptic, compared to the horns.  This event of the sun passing between the horns happens even now.
To misinterpret the Bull of Heaven as a solar system object/configuration, would be to throw out all the important information that has been passed down on ages.   All ages defined as the point of entrance of the sun into a particular sign.  As in, “when the sun comes to the first point of Aries on the Vernal equinox….”
From: Jim Weninger <jwen1@yahoo.com>
To: Juan Calsiano <juancalsiano@gmail.com>; “dj@argos.vu” <dj@argos.vu>; jhafner <jhafner@swcp.com
Sent: Monday, September 11, 2017 9:10 PM
Subject: Re: Taurus History

 

And just to get Taurus the bull out from where it should not be: the sun in Taurus is the figure of the bull with the sun between its horns. If we do not take it out of context as some catastrophists do, we find that the sun in Taurus, depicted as bull with sun between its horns, was depicted as a time marker. 
  I’ll quote from “Star Lore” by William Tyler Olcott,”the sun in Taurus was deified under the symbol of the bull…and is seen in the ruins of Egypt and Assyria” and “the Persians also were worshippers of the bull…and designated successive signs of the Zodiac by letters….with them A stands for Taurus…indicating that they considered the Bull the first sign of the zodiac” and “in fact in all the ancient zodiacs that have come down to us Taurus apparently began the year, and it seems to have been regarded as a Bull in all of the ancient Mediterranean cultures”

Also”the bull was an important object of worship with the Druids, and their great Tauric festival was held when the sun entered this constellation”

The point is merely that we can see that the bull and sun between the bulls horns was a symbol used even in the earliest ages to denote a constellation and our “time” within it. 

I am not arguing against a polar alignment of planets, but not ALL mythology is about this one event. Especially when we have clear written records that do say what this figure was all about.  




Sent from my iPhone


> On Sep 11, 2017, at 8:10 PM, Jim Weninger <jwen1@yahoo.com> wrote:

http://www.astrology-zodiac- signs.com/history/taurus/

> This would suggest that it was in Babylonian times that Taurus was first identified as the “Bull of Heaven”.
> I’ll try to search for a better reference
8 Attachments

 

001 EU Meetup September 4, 2017

Jean, Jim and Juan,

Great conversation last week.

Just want to extend the invitation for the meeting tomorrow.
Skype meetup on
Monday: September 4, 2017 at
UTC-3      8:00pm
Mountain  5:00pm
PST          4:00pm
Any topics you’d like to cover I can collate here so we can reference them during the meeting.
Have a great Sunday.
🙂
/dj


000 EU Meetup Aug 28, 2017

​It was great to meet up on Skype today.

Here are a few references from the conversation:

Hopf fibration







24,000 cycle – Esoteric




Also find included, some info on the Solvay Conferences – (wanted to check it out)

Have a great week, I’ll touch base over the weekend.

🙂

/dj

Vortex – Spatial Frequency

Unity Native Spline

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using System.Linq;
using UnityEngine.Serialization;

[AddComponentMenu("Miscellaneous/Bezier Spline")]
public class Bezier3DSpline : MonoBehaviour{

	public int KnotCount { get { return curves.Length+(closed?0:1); } }
	public int CurveCount { get { return curves.Length; } }
    /// <summary> Interpolation steps per curve </summary>
    public int cacheDensity { get { return _cacheDensity; } }
    [SerializeField] protected int _cacheDensity = 60;
    /// <summary> Whether the end of the spline connects to the start of the spline </summary>
    public bool closed { get { return _closed; } }
    [SerializeField] protected bool _closed = false;
    /// <summary> Sum of all curve lengths </summary>
    public float totalLength { get { return _totalLength; } }
    [SerializeField] protected float _totalLength = 2.370671f;
    /// <summary> Curves of the spline </summary>
    [SerializeField] protected Bezier3DCurve[] curves = new Bezier3DCurve[] { new Bezier3DCurve( new Vector3(-1,0,0), new Vector3(1,0,1), new Vector3(-1,0,-1), new Vector3(1,0,0), 60)};
    /// <summary> Automatic knots don't have handles. Instead they have a percentage and adjust their handles accordingly. A percentage of 0 indicates that this is not automatic </summary>
    [SerializeField] protected List<float> autoKnot = new List<float>() { 0, 0 };
    [SerializeField] protected List<NullableQuaternion> orientations = new List<NullableQuaternion>() { new NullableQuaternion(null), new NullableQuaternion(null) };
    [SerializeField] protected Vector3[] tangentCache = new Vector3[0];

    #region Public methods

    #region Public: get

    public float DistanceToTime(float dist) {
        float t = 0f;
        for (int i = 0; i < CurveCount; i++) {
            if (curves[i].length < dist) {
                dist -= curves[i].length;
                t += 1f / CurveCount;
            }
            else {
                t += curves[i].Dist2Time(dist) / CurveCount;
                return t;
            }
        }
        return 1f;
    }

    /// <summary> Get <see cref="Bezier3DCurve"/> by index </summary>
    public Bezier3DCurve GetCurve(int i) {
        if (i >= CurveCount || i < 0) throw new System.IndexOutOfRangeException("Cuve index " + i + " out of range");
        return curves[i];
    }

    /// <summary> Return <see cref="Knot"/> info in local coordinates </summary>
    public Knot GetKnot(int i) {
        if (i == 0) {
            if (closed) return new Knot(curves[0].a, curves[CurveCount - 1].c, curves[0].b, autoKnot[i], orientations[i].NullableValue);
            else return new Knot(curves[0].a, Vector3.zero, curves[0].b, autoKnot[i], orientations[i].NullableValue);
        }
        else if (i == CurveCount) {
            return new Knot(curves[i - 1].d, curves[i - 1].c, Vector3.zero, autoKnot[i], orientations[i].NullableValue);
        }
        else {
            return new Knot(curves[i].a, curves[i - 1].c, curves[i].b, autoKnot[i], orientations[i].NullableValue);
        }
    }

    #region Public get: Forward
    /// <summary> Return forward vector at set distance along the <see cref="Bezier3DSpline"/>. </summary>
    public Vector3 GetForward(float dist) {
        return transform.TransformDirection(GetForwardLocal(dist));
    }

    /// <summary> Return forward vector at set distance along the <see cref="Bezier3DSpline"/> in local coordinates. </summary>
    public Vector3 GetForwardLocal(float dist) {
        Bezier3DCurve curve = GetCurveDistance(dist, out dist);
        return curve.GetForward(curve.Dist2Time(dist));
    }

    /// <summary> Return forward vector at set distance along the <see cref="Bezier3DSpline"/>. Uses approximation. </summary>
    public Vector3 GetForwardFast(float dist) {
        return transform.TransformDirection(GetForwardLocalFast(dist));
    }

    /// <summary> Return forward vector at set distance along the <see cref="Bezier3DSpline"/> in local coordinates. Uses approximation. </summary>
    public Vector3 GetForwardLocalFast(float dist) {
        Bezier3DCurve curve = GetCurveDistance(dist, out dist);
        return curve.GetForwardFast(curve.Dist2Time(dist));
    }
    #endregion

    #region Public get: Up
    /// <summary> Return up vector at set distance along the <see cref="Bezier3DSpline"/>. </summary>
    public Vector3 GetUp(float dist) {
        return GetUp(dist, GetForward(dist), false);
    }

    /// <summary> Return up vector at set distance along the <see cref="Bezier3DSpline"/> in local coordinates. </summary>
    public Vector3 GetUpLocal(float dist) {
        return GetUp(dist, GetForward(dist), true);
    }
    #endregion

    #region Public get: Point
    /// <summary> Return up vector at set distance along the <see cref="Bezier3DSpline"/>. </summary>
    public Vector3 GetPoint(float dist) {
        Bezier3DCurve curve = GetCurveDistance(dist, out dist);
        return transform.TransformPoint(curve.GetPoint(curve.Dist2Time(dist)));
    }

    /// <summary> Return point at lerped position where 0 = start, 1 = end </summary>
    public Vector3 GetPointLocal(float dist) {
        Bezier3DCurve curve = GetCurveDistance(dist, out dist);
        return curve.GetPoint(curve.Dist2Time(dist));
    }
    #endregion

    #region Public get: Orientation
    public Quaternion GetOrientation(float dist) {
        Vector3 forward = GetForward(dist);
        Vector3 up = GetUp(dist, forward, false);
        if (forward.sqrMagnitude != 0) return Quaternion.LookRotation(forward, up);
        else return Quaternion.identity;
    }

    public Quaternion GetOrientationFast(float dist) {
        Vector3 forward = GetForwardFast(dist);
        Vector3 up = GetUp(dist, forward, false);
        if (forward.sqrMagnitude != 0) return Quaternion.LookRotation(forward, up);
        else return Quaternion.identity;
    }

    public Quaternion GetOrientationLocal(float dist) {
        Vector3 forward = GetForwardLocal(dist);
        Vector3 up = GetUp(dist, forward, true);
        if (forward.sqrMagnitude != 0) return Quaternion.LookRotation(forward, up);
        else return Quaternion.identity;
    }

    public Quaternion GetOrientationLocalFast(float dist) {
        Vector3 forward = GetForwardLocalFast(dist);
        Vector3 up = GetUp(dist, forward, true);
        if (forward.sqrMagnitude != 0) return Quaternion.LookRotation(forward, up);
        else return Quaternion.identity;
    }
    #endregion

    #endregion

    #region Public: Set
    /// <summary> Setting spline to closed will generate an extra curve, connecting end point to start point </summary>
    public void SetClosed(bool closed) {
        if (closed != _closed) {
            _closed = closed;
            if (closed) {
                List<Bezier3DCurve> curveList = new List<Bezier3DCurve>(curves);
                curveList.Add(new Bezier3DCurve(curves[CurveCount - 1].d, -curves[CurveCount - 1].c, -curves[0].b, curves[0].a, cacheDensity));
                curves = curveList.ToArray();
            }
            else {
                List<Bezier3DCurve> curveList = new List<Bezier3DCurve>(curves);
                curveList.RemoveAt(CurveCount - 1);
                curves = curveList.ToArray();
            }
            _totalLength = GetTotalLength();
        }
    }

    /// <summary> Recache all individual curves with new step amount </summary> 
    /// <param name="density"> Number of steps per curve </param>
    public void SetCacheDensity(int steps) {
        _cacheDensity = steps;
        for (int i = 0; i < CurveCount; i++) {
            curves[i] = new Bezier3DCurve(curves[i].a, curves[i].b, curves[i].c, curves[i].d, _cacheDensity);
        }
        _totalLength = GetTotalLength();
    }

    public void RemoveKnot(int i) {
        if (i == 0) {
            Knot knot = GetKnot(1);

            List<Bezier3DCurve> curveList = new List<Bezier3DCurve>(curves);
            curveList.RemoveAt(0);
            curves = curveList.ToArray();

            autoKnot.RemoveAt(0);
            orientations.RemoveAt(0);

            SetKnot(0, knot);
        }
        else if (i == CurveCount) {

            List<Bezier3DCurve> curveList = new List<Bezier3DCurve>(curves);
            curveList.RemoveAt(i - 1);
            curves = curveList.ToArray();

            autoKnot.RemoveAt(i);
            orientations.RemoveAt(i);

            if (autoKnot[KnotCount - 1] != 0) SetKnot(KnotCount - 1, GetKnot(KnotCount - 1));
        }
        else {
            int preCurveIndex, postCurveIndex;
            GetCurveIndicesForKnot(i, out preCurveIndex, out postCurveIndex);

            Bezier3DCurve curve = new Bezier3DCurve(curves[preCurveIndex].a, curves[preCurveIndex].b, curves[postCurveIndex].c, curves[postCurveIndex].d, cacheDensity);

            curves[preCurveIndex] = curve;

            List<Bezier3DCurve> curveList = new List<Bezier3DCurve>(curves);
            curveList.RemoveAt(postCurveIndex);
            curves = curveList.ToArray();

            autoKnot.RemoveAt(i);
            orientations.RemoveAt(i);

            int preKnotIndex, postKnotIndex;
            GetKnotIndicesForKnot(i, out preKnotIndex, out postKnotIndex);

            SetKnot(preKnotIndex, GetKnot(preKnotIndex));
        }
    }

    public void AddKnot(Knot knot) {
        Bezier3DCurve curve = new Bezier3DCurve(curves[CurveCount - 1].d, -curves[CurveCount - 1].c, knot.handleIn, knot.position, cacheDensity);

        List<Bezier3DCurve> curveList = new List<Bezier3DCurve>(curves);
        curveList.Add(curve);
        curves = curveList.ToArray();

        autoKnot.Add(knot.auto);
        orientations.Add(knot.orientation);
        SetKnot(KnotCount - 1, knot);
    }

    public void InsertKnot(int i, Knot knot) {
        Bezier3DCurve curve;
        if (i == 0) curve = new Bezier3DCurve(knot.position, knot.handleOut, -curves[0].b, curves[0].a, cacheDensity);
        else if (i == CurveCount) curve = GetCurve(i - 1);
        else curve = GetCurve(i);

        List<Bezier3DCurve> curveList = new List<Bezier3DCurve>(curves);
        curveList.Insert(i, curve);
        curves = curveList.ToArray();

        autoKnot.Insert(i, knot.auto);
        orientations.Insert(i, knot.orientation);
        SetKnot(i, knot);
    }

    /// <summary> Set Knot info in local coordinates </summary>
    public void SetKnot(int i, Knot knot) {
        //If knot is set to auto, adjust handles accordingly
        orientations[i] = knot.orientation;
        autoKnot[i] = knot.auto;
        if (knot.auto != 0) AutomateHandles(i, ref knot);

        //Automate knots around this knot
        int preKnotIndex, postKnotIndex;
        GetKnotIndicesForKnot(i, out preKnotIndex, out postKnotIndex);

        Knot preKnot = new Knot();
        if (preKnotIndex != -1) {
            preKnot = GetKnot(preKnotIndex);
            if (preKnot.auto != 0) {
                int preKnotPreCurveIndex, preKnotPostCurveIndex;
                GetCurveIndicesForKnot(preKnotIndex, out preKnotPreCurveIndex, out preKnotPostCurveIndex);
                if (preKnotPreCurveIndex != -1) {
                    AutomateHandles(preKnotIndex, ref preKnot, curves[preKnotPreCurveIndex].a, knot.position);
                    curves[preKnotPreCurveIndex] = new Bezier3DCurve(curves[preKnotPreCurveIndex].a, curves[preKnotPreCurveIndex].b, preKnot.handleIn, preKnot.position, cacheDensity);
                }
                else {
                    AutomateHandles(preKnotIndex, ref preKnot, Vector3.zero, knot.position);
                }
            }
        }

        Knot postKnot = new Knot();
        if (postKnotIndex != -1) {
            postKnot = GetKnot(postKnotIndex);
            if (postKnot.auto != 0) {
                int postKnotPreCurveIndex, postKnotPostCurveIndex;
                GetCurveIndicesForKnot(postKnotIndex, out postKnotPreCurveIndex, out postKnotPostCurveIndex);
                if (postKnotPostCurveIndex != -1) {
                    AutomateHandles(postKnotIndex, ref postKnot, knot.position, curves[postKnotPostCurveIndex].d);
                    curves[postKnotPostCurveIndex] = new Bezier3DCurve(postKnot.position, postKnot.handleOut, curves[postKnotPostCurveIndex].c, curves[postKnotPostCurveIndex].d, cacheDensity);
                }
                else {
                    AutomateHandles(postKnotIndex, ref postKnot, knot.position, Vector3.zero);
                }
            }
        }

        //Get the curve indices in direct contact with knot
        int preCurveIndex, postCurveIndex;
        GetCurveIndicesForKnot(i, out preCurveIndex, out postCurveIndex);

        //Adjust curves in direct contact with the knot
        if (preCurveIndex != -1) curves[preCurveIndex] = new Bezier3DCurve(preKnot.position, preKnot.handleOut, knot.handleIn, knot.position, cacheDensity);
        if (postCurveIndex != -1) curves[postCurveIndex] = new Bezier3DCurve(knot.position, knot.handleOut, postKnot.handleIn, postKnot.position, cacheDensity);

        _totalLength = GetTotalLength();

    }

    /// <summary> Flip the spline </summary>
    public void Flip() {
        Bezier3DCurve[] curves = new Bezier3DCurve[CurveCount];
        for (int i = 0; i < CurveCount; i++) {
            curves[CurveCount - 1 - i] = new Bezier3DCurve(this.curves[i].d, this.curves[i].c, this.curves[i].b, this.curves[i].a, cacheDensity);
        }
        this.curves = curves;
        autoKnot.Reverse();
        orientations.Reverse();
    }
    #endregion

    #endregion

    public struct Knot {
        public Vector3 position;
        public Vector3 handleIn;
        public Vector3 handleOut;
        public float auto;
        public Quaternion? orientation;

        /// <summary> Constructor </summary>
        /// <param name="position">Position of the knot local to spline transform</param>
        /// <param name="handleIn">Left handle position local to knot position</param>
        /// <param name="handleOut">Right handle position local to knot position</param>
        /// <param name="automatic">Any value above 0 will result in an automatically configured knot (ignoring handle inputs)</param>
        public Knot(Vector3 position, Vector3 handleIn, Vector3 handleOut, float automatic = 0f, Quaternion? orientation = null) {
            this.position = position;
            this.handleIn = handleIn;
            this.handleOut = handleOut;
            this.auto = automatic;
            this.orientation = orientation;
        }
    }

    #region Private methods
    private Vector3 GetUp(float dist, Vector3 tangent, bool local) {
        float t = DistanceToTime(dist);
        t *= CurveCount;

        Quaternion rot_a = Quaternion.identity, rot_b = Quaternion.identity;
        int t_a = 0, t_b = 0;

        //Find preceding rotation
        for (int i = Mathf.Min((int)t, CurveCount); i >= 0; i--) {
            i = (int)Mathf.Repeat(i, KnotCount - 1);
            if (orientations[i].HasValue) {
                rot_a = orientations[i].Value;
                rot_b = orientations[i].Value;
                t_a = i;
                t_b = i;
                break;
            }
        }
        //Find proceding rotation
        for (int i = Mathf.Max((int)t + 1, 0); i < orientations.Count; i++) {
            if (orientations[i].HasValue) {
                rot_b = orientations[i].Value;
                t_b = i;
                break;
            }
        }
        t = Mathf.InverseLerp(t_a, t_b, t);
        Quaternion rot = Quaternion.Lerp(rot_a, rot_b, t);
        if (!local) rot = transform.rotation * rot;
        //Debug.Log(t_a + " / " + t_b + " / " + t);
        return Vector3.ProjectOnPlane(rot * Vector3.up, tangent).normalized;
    }

    /// <summary> Get the curve indices in direct contact with knot </summary>
    private void GetCurveIndicesForKnot(int knotIndex, out int preCurveIndex, out int postCurveIndex) {
        //Get the curve index in direct contact with, before the knot
        preCurveIndex = -1;
        if (knotIndex != 0) preCurveIndex = knotIndex - 1;
        else if (closed) preCurveIndex = CurveCount - 1;

        //Get the curve index in direct contact with, after the knot
        postCurveIndex = -1;
        if (knotIndex != CurveCount) postCurveIndex = knotIndex;
        else if (closed) postCurveIndex = 0;
    }

    /// <summary> Get the knot indices in direct contact with knot </summary>
    private void GetKnotIndicesForKnot(int knotIndex, out int preKnotIndex, out int postKnotIndex) {
        //Get the curve index in direct contact with, before the knot
        preKnotIndex = -1;
        if (knotIndex != 0) preKnotIndex = knotIndex - 1;
        else if (closed) preKnotIndex = KnotCount - 1;

        //Get the curve index in direct contact with, after the knot
        postKnotIndex = -1;
        if (knotIndex != KnotCount - 1) postKnotIndex = knotIndex + 1;
        else if (closed) postKnotIndex = 0;
    }

    private Bezier3DCurve GetCurve(float splineT, out float curveT) {
        splineT *= CurveCount;
        for (int i = 0; i < CurveCount; i++) {
            if (splineT > 1f) splineT -= 1f;
            else {
                curveT = splineT;
                return curves[i];
            }
        }
        curveT = 1f;
        return curves[CurveCount - 1];
    }

    private Bezier3DCurve GetCurveDistance(float splineDist, out float curveDist) {
        for (int i = 0; i < CurveCount; i++) {
            if (curves[i].length < splineDist) splineDist -= curves[i].length;
            else {
                curveDist = splineDist;
                return curves[i];
            }
        }
        curveDist = curves[CurveCount -1].length;
        return curves[CurveCount - 1];
    }

    /// <summary> Automate handles based on previous and next point positions </summary>
    private void AutomateHandles(int i, ref Knot knot) {
        //Terminology: Points are referred to as A B and C
        //A = prev point, B = current point, C = next point

        Vector3 prevPos;
        if (i != 0) prevPos = curves[i - 1].a;
        else if (closed) prevPos = curves[CurveCount - 1].a;
        else prevPos = Vector3.zero;

        Vector3 nextPos;
        if (i != KnotCount - 1) nextPos = curves[i].d;
        else if (closed) nextPos = curves[0].a;
        else nextPos = Vector3.zero;

        AutomateHandles(i, ref knot, prevPos, nextPos);
    }

    /// <summary> Automate handles based on previous and next point positions </summary>
    private void AutomateHandles(int i, ref Knot knot, Vector3 prevPos, Vector3 nextPos) {
        //Terminology: Points are referred to as A B and C
        //A = prev point, B = current point, C = next point
        float amount = knot.auto;

        //Calculate directional vectors
        Vector3 AB = knot.position - prevPos;
        Vector3 CB = knot.position - nextPos;
        //Calculate the across vector
        Vector3 AB_CB = (CB.normalized - AB.normalized).normalized;

        if (!closed) {
            if (i == 0) {
                knot.handleOut = CB * -amount;
            }
            else if (i == CurveCount) {
                knot.handleIn = AB * -amount;
            }
            else {
                knot.handleOut = -AB_CB * CB.magnitude * amount;
                knot.handleIn = AB_CB * AB.magnitude * amount;
            }
        }
        else {
            if (KnotCount == 2) {
                Vector3 left = new Vector3(AB.z, 0,-AB.x) * amount;
                if (i == 0) {
                    knot.handleIn = left;
                    knot.handleOut = -left;
                }
                if (i == 1) {
                    knot.handleIn = left;
                    knot.handleOut = -left;
                }
            }
            else {
            knot.handleIn = AB_CB * AB.magnitude * amount;
            knot.handleOut = -AB_CB * CB.magnitude * amount;
            }
        }
    }

    private float GetTotalLength() {
        float length = 0f;
        for (int i = 0; i < CurveCount; i++) {
            length += curves[i].length;
        }
        return length;
    }
    #endregion

    /// <summary> Unity doesn't support serialization of nullable types, so here's a custom struct that does exactly the same thing </summary>
    [Serializable]
    protected struct NullableQuaternion {
        public Quaternion Value { get { return rotation; } }
        public Quaternion? NullableValue { get { if (hasValue) return rotation; else return null; } }
        public bool HasValue { get { return hasValue; } }

        [SerializeField] private Quaternion rotation;
        [SerializeField] private bool hasValue;

        public NullableQuaternion(Quaternion? rot) {
            rotation = rot.HasValue?rot.Value:Quaternion.identity;
            hasValue = rot.HasValue;
        }

        //  User-defined conversion from nullable type to NullableQuaternion
        public static implicit operator NullableQuaternion(Quaternion? r) {
            return new NullableQuaternion(r);
        }
    }
#if UNITY_EDITOR
    void OnDrawGizmos() {
        //Set color depending on selection
        if (Array.IndexOf(UnityEditor.Selection.gameObjects, gameObject) >= 0) {
            Gizmos.color = Color.yellow;
        } else  Gizmos.color = new Color(1, 0.6f, 0f);

        //Loop through each curve in spline
        for (int i = 0; i < CurveCount; i++) {
            Bezier3DCurve curve = GetCurve(i);

            //Get curve in world space
            Vector3 a, b, c, d;
            a = transform.TransformPoint(curve.a);
            b = transform.TransformPoint(curve.b + curve.a);
            c = transform.TransformPoint(curve.c + curve.d);
            d = transform.TransformPoint(curve.d);

            int segments = 50;
            float spacing = 1f / segments;
            Vector3 prev = Bezier3DCurve.GetPoint(a, b, c, d, 0f);
            for (int k = 0; k <= segments; k++) {
                Vector3 cur = Bezier3DCurve.GetPoint(a, b, c, d, k * spacing);
                Gizmos.DrawLine(prev, cur);
                prev = cur;
            }
        }
    }
#endif
}