It is simpler to construct a new quaternion for [v1, s1] and let Unity multiply them:

```
Quaternion qw0 = new Quaternion(w.x, w.y, w.z, 0);
Quaternion quatprod = qw0 * q;
```

qw0 is not normalized and I’m not sure how well Unity’s Quaternion type caters for that. The reason I doubt this is that it lacks so many operators, such as addition, magnitude, and normalization. It smells like it only supports unit quaternions.

However, I tried it and it seems to work OK - it correctly stores qw0 and quatprod, without auto-normalizing them. So you might be OK.

The next step in your code will cause more problems as you need to multiply a quaternion by a scalar, and to add two quaternions together, neither of which is provided by Unity’s Quaternion type. You can define them yourself though and it should work.

If on the other hand you do want to do all the maths yourself without using the Quaternion type, then you should be more explicit about breaking the input quaternion into a vector/scalar pair first:

```
Vector3 qV = new Vector3(q.x, q.y, q.z);
float qS = q.w;
```

Then calculate the result, as a vector/scalar pair:

```
Vector3 quatprodV = qS * w + Vector3.Cross(w, qV);
float quatprodS = -Vector3.Dot(w, qV);
```

Then integrate your (qV, qS) pair:

```
qV += (Time.deltaTime / 2) * quatprodV;
qS += (Time.deltaTime / 2) * quatprodS;
```

Although you didn’t mention it, I think you would now normalize the quaternion.

```
float magnitude = Mathf.Sqrt(qV.sqrMagnitude + qS * qS);
qV /= magnitude;
qS /= magnitude;
```

And now you can repack q from (qV, qS):

```
q = new Quaternion(qV.x, qV.y, qV.z, qS);
```