[RESOLVIDO] Rotação de um gameobject sem que os filhos se alterem?

Sou novo na plataforma, estou com uma dúvida sobre rotação. Estou criando uma molécula composta somente com código, utilizando esferas e cilindros. Moléculas simples como a do metano funcionam já, porém ao adicionar mais um carbono ao lado para expandir a molécula preciso que suas ligações com os hidrogênios virem em 180º em relação ao carbono com quem esse novo carbono se ligou. Porem ao utilizar o transform.lookAt() as ligações com os hidrogênios(que são "filhos" do objeto carbono) são distorcidas. Tem alguma forma de rotacionar o gameobject carbono sem que os hidrogênios se distorçam?

Bem, tem como mandar prints para exemplificar.

química não é meu forte...

então um exemplo visual viria bem a calhar

e para mandar prints tu vai precisar usar algum site de upload eu recomendo o [url= imgur.com]imgur.com[/url]

Usar somente o LookAt vai deixar isso complexo beem rápido. 
Primeiro que ele só funciona bem no espaço global, ou seja, utilizando posições absolutas no mundo, como cada átomo vai ficar numa posição específica na molécula, colocando três ou mais em cadeia já vai ser um pesadelo pra gerenciar. 
Eu tentaria manter tudo no espaço local, deixando as posições sempre relativas ao átomo anterior ou ao objeto pai, mas usando uma lista de posições que varie conforme a quantidade de itens conectados. 
Daria pra criar um array de posições relativas possíveis com cada quantidade de itens conectados, aí quando você fosse conectando, cada átomo manteria um registro de quantas ligações ele possui, olharia no array onde cada átomo se posicionaria, e ele se encarregaria de deixar os que estão conectados à ele, no local correto.

Mexer com rotações relativas é um negócio complicado, kkk.
Pra facilitar a tarefa, usei um objeto de referência, ele já tem grupos de objetos filhos nas rotações corretas, no exemplo fiz três grupos tendo 1, 2 e 3 filhos.

O Átomo atual passa sua rotação pro objeto de referência, fazendo com que os filhos da referência fiquem apontando na direção correta, então basta somar a posição do átomo atual + a direção vinda do filho X da referencia * uma distância configurável, que o resultado é a posição que cada átomo filho na hierarquia receberá. 



Aqui está o link desse projeto, recomendo que baixe e veja como a referência foi configurada.
https://drive.google.com/file/d/1Ev4LH1XYys0Ux9XIfbJDWE1p6P2Ny_4h/view?usp=sharing

Utilizei o forward de cada objeto como direção de encaixe no átomo anterior.
Não sei direito se será suficiente pra moléculas mais complexas, como o benzeno ou tolueno, nas quais ao menos um átomo "filho", tem um átomo "pai" como seu próprio "filho" (formando um circulo)... enfim, ao menos já e um ponto de começo.

Código:

using System.Collections.Generic;
using UnityEngine;

public class Atomo : MonoBehaviour
{
    public List<Atomo> atomosConectados;
    public Transform referencia;
    public float distanciaAtomo = 4;

    

    private void OnDrawGizmos()
    {
        CorrigirPosicoes();
        //Direcao em que o atomo se conecta ao anterior
        Vector3 direcaoConexao = transform.position + transform.forward / 2;

        Gizmos.color = Color.red;
        Gizmos.DrawSphere(direcaoConexao, 0.1f);

        //------- Direcões dos atomos que se conectam a mim -------|        
        Gizmos.color = Color.blue;
        if(atomosConectados!=null && atomosConectados.Count > 0)
        {
            Vector3[] conexoes = new Vector3[atomosConectados.Count];
            referencia.forward = transform.forward;

            if (conexoes.Length == 1)
            {
                conexoes[0] = transform.position + referencia.GetChild(1).GetChild(0).position;
            }
            else if(conexoes.Length==2)
            {
                conexoes[0] = transform.position + referencia.GetChild(2).GetChild(0).position;
                conexoes[1] = transform.position + referencia.GetChild(2).GetChild(1).position;
            }
            else if (conexoes.Length == 3)
            {
                conexoes[0] = transform.position + referencia.GetChild(3).GetChild(0).position;
                conexoes[1] = transform.position + referencia.GetChild(3).GetChild(1).position;
                conexoes[2] = transform.position + referencia.GetChild(3).GetChild(2).position;
            }

            for (int i = 0; i < conexoes.Length; i++)
            {
                Gizmos.DrawSphere(conexoes[i], 0.1f);
                Gizmos.DrawLine(transform.position, atomosConectados[i].transform.position);
            }
        }
    }

    private void CorrigirPosicoes()
    {
        if (atomosConectados != null && atomosConectados.Count > 0)
        {
            Vector3[] conexoes = new Vector3[atomosConectados.Count];
            referencia.forward = transform.forward;

            if (conexoes.Length == 1)
            {
                conexoes[0] = referencia.GetChild(1).GetChild(0).position;
            }
            else if (conexoes.Length == 2)
            {
                conexoes[0] = referencia.GetChild(2).GetChild(0).position;
                conexoes[1] = referencia.GetChild(2).GetChild(1).position;
            }
            else if (conexoes.Length == 3)
            {
                conexoes[0] = referencia.GetChild(3).GetChild(0).position;
                conexoes[1] = referencia.GetChild(3).GetChild(1).position;
                conexoes[2] = referencia.GetChild(3).GetChild(2).position;
            }

            for (int i = 0; i < conexoes.Length; i++)
            {
                atomosConectados[i].transform.position = transform.position + (conexoes[i] * distanciaAtomo);
                atomosConectados[i].transform.LookAt(transform.position);
            }
        }
    }
}

Com a ideia desse código consegui resolver 100% do problema q acontecia hehe, muito obrigado!!