generating the L-system string

First, we need to create the L-system from the input, which consists of the axiom and the rules. We start with an empty string and iterate through it (between 4 and 7 iterations for my plant editor, though the number can be customized).

For each iteration, we replace each character in the string according to the predefined rules. The resulting string is relatively long, with each character representing an action for the tree to grow. 

std::string result = myAxiom;
	for (int i = 0; i < myDepth; ++i)
	{
                bool ruleApplied = false;

		std::string newResult = "";
		for (char c : result)
		{
			if (c == 'F')
			{
				newResult += myRules[static_cast<int>
				ruleApplied = true;
			}

			else if (c == 'X')
			{
				newResult += myRules[static_cast<int>
				ruleApplied = true;
			}

			if (!ruleApplied)
			{
				newResult += c;
			}
		}
		result = newResult;
	}
	myResult = result;

building the tree

Once the L-system string is generated we can use it to create a mesh. The Mesh is built procedurally by going through each character in the string and handling each case separately. Either a new branch is created, or the current branch should grow forward, or we rotate etc.

for (char c : myParams.lSystem.GetResult())
{
    switch (c)
    {
    case 'F': // Forward
        // Create new branch node
        std::shared_ptr<PlantNode> newBranch = std::make_shared<PlantNode>();
        
        //Transform the new branch
        newBranch->myParent = currentNode;
        newBranch->myLength = 
currentNode->myLength * myParams.generalScaleFactorHeight;
        newBranch->myWidth = currentNode->myWidth * myParams.generalScaleFactorWidth;
        newBranch->myTransform = currentNode->myTransform;

        vector3f growth = newBranch->myTransform.GetUp() * newBranch->myLength;
        newBranch->myTransform.AccumulateTranslation(growth);
        
        //create vertices
        newBranch->CreateVertices(true, myPlantData);

        currentNode->myChildren.push_back(newBranch);
        currentNode = currentNode->myChildren.back().get();
        break;

    case '+': // Rotate right
        currentNode->myTransform.AddRotation(myParams.rotationA);
        break;

    case '-': // Rotate left
        currentNode->myTransform.AddRotation(myParams.rotationB);
        break;

    case '[': // Open branch
        nodeStack.push(currentNode);

        // Create new branch for branching
        std::shared_ptr<PlantNode> newBranchForOpen = std::make_shared<PlantNode>();
        newBranchForOpen->myVertexIndexes = currentNode->myVertexIndexes;
        newBranchForOpen->myParent = currentNode;

        // Update branch parameters
        newBranchForOpen->myTransform = currentNode->myTransform;
        newBranchForOpen->myLength = currentNode->myLength;
        newBranchForOpen->myWidth = currentNode->myWidth;

        currentNode->myChildren.push_back(newBranchForOpen);
        currentNode = newBranchForOpen.get();
        break;

    default:
        break;
    }
}

The PlantNode class

Each PlantNode represents a branch in the tree, and it internally manages the mesh for that branch. 

The PlantNode holds pointers to the mesh vertices and can acess its own children, and this is what builds the tree structure.

The CreateVertices function is responsible for creating the mesh for each branch by generating indices that describe how to connect the vertices.

class PlantNode
{
public:
    PlantNode();
    ~PlantNode() = default;

    void GenerateVertexData(sPlantData& aPlantData);
    void CreateVertices(bool allocateVertices, sPlantData& aPlantData);

private:
    friend class Plant;

    std::vector<unsigned int> myVertexIndexes;
    std::vector<std::shared_ptr<PlantNode>> myChildren;
    std::vector<Leaf*> myLeaves;
    PlantNode* myParent = nullptr;
    Transform myTransform;
    float myLength = 0.0f;
    float myWidth = 0.0f;
};

void PlantNode::CreateVertices(bool allocateVertices, sPlantData& aPlantData)
{
	GenerateVertexData(allocateVertices, aPlantData);

	if (allocateVertices)
	{
		// Generate indices for the mesh
		for (int i = 0; i < myVertexIndexes.size(); ++i)
		{
			unsigned int parentIndex1 = myParent->myVertexIndexes[i];
			unsigned int parentIndex2 = myParent->myVertexIndexes[(i + 1) % aPlantData.numSides];
			unsigned int childIndex = myVertexIndexes[i];
			unsigned int nextChildIndex = myVertexIndexes[(i + 1) % aPlantData.numSides];

			if (parentIndex1 < aPlantData.vertexCount && parentIndex2 < aPlantData.vertexCount &&
				childIndex < aPlantData.vertexCount && nextChildIndex < aPlantData.vertexCount)
			{
				aPlantData.mesh->AddIndex(parentIndex1);
				aPlantData.mesh->AddIndex(childIndex);
				aPlantData.mesh->AddIndex(parentIndex2);

				aPlantData.mesh->AddIndex(parentIndex2);
				aPlantData.mesh->AddIndex(childIndex);
				aPlantData.mesh->AddIndex(nextChildIndex);
			}
		}
	}
}