OpenGL ES 2 (iOS) Morph / Animate between two set of vertexes

Question

I have two sets of vertexes used as a line strip:

1. Vertexes1
2. Vertexes2

It's important to know that these vertexes have previously unknown values, as they are dynamic.

I want to make an animated transition (morph) between these two. I have come up with two different ways of doing this:

Option 1:

Set a Time uniform in the vertex shader, that goes from 0 - 1, where I can do something like this:

// Inside main() in the vertex shader
float originX = Position.x;
float destinationX = DestinationVertexPosition.x;
float interpolatedX = originX + (destinationX - originX) * Time;

gl_Position.x = interpolatedX;

As you probably see, this has one problem: How do I get the "DestinationVertexPosition" in there?

Option 2:

Make the interpolation calculation outside the vertex shader, where I loop through each vertex and create a third vertex set for the interpolated values, and use that to render:

// Pre render
// Use this vertex set to render
InterpolatedVertexes

for (unsigned int i = 0; i < vertexCount; i++) {
   float originX = Vertexes1[i].x;
   float destinationX = Vertexes2[i].x;
   float interpolatedX = originX + (destinationX - originX) * Time;

   InterpolatedVertexes[i].x = interpolatedX;
}

I have highly simplified these two code snippets, just to make the idea clear.

Now, from the two options, I feel like the first one is definitely better in terms of performance, given stuff happens at the shader level, AND I don't have to create a new set of vertexes each time the "Time" is updated.

So, now that the introduction to the problem has been covered, I would appreciate any of the following three things:

1. A discussion of better ways of achieving the desired results in OpenGL ES 2 (iOS).
2. A discussion about how Option 1 could be implemented properly, either by providing the "DestinationVertexPosition" or by modifying the idea somehow, to better achieve the same result.
3. A discussion about how Option 2 could be implemented.

Answer 1

In ES 2 you specify such attributes as you like — there's therefore no problem with specifying attributes for both origin and destination, and doing the linear interpolation between them in the vertex shader. However you really shouldn't do it component by component as your code suggests you want to as GPUs are vector processors, and the mix GLSL function will do the linear blend you want. So e.g. (with obvious inefficiencies and assumptions)

int sourceAttribute = glGetAttribLocation(shader, "sourceVertex");
glVertexAttribPointer(sourceAttribute, 3, GL_FLOAT, GL_FALSE, 0, sourceLocations);

int destAttribute = glGetAttribLocation(shader, "destVertex");
glVertexAttribPointer(destAttribute, 3, GL_FLOAT, GL_FALSE, 0, destLocations);

And:

gl_Position = vec4(mix(sourceVertex, destVertex, Time), 1.0);