General.cpp

#include "General.h"

#include "i18n.h"
#include "imainframe.h"
#include "itextstream.h"
#include "ipatch.h"
#include "patch/PatchNode.h"
#include "patch/Patch.h"
#include "messages/TextureChanged.h"
#include "selection/algorithm/Primitives.h"

#include "string/convert.h"
#include "scenelib.h"
#include "command/ExecutionFailure.h"
#include "PatchIterators.h"

namespace patch
{

namespace algorithm
{

void thicken(const PatchNodePtr& sourcePatch, float thickness, bool createSeams, int axis)
{
	if (axis < 0 || axis > 3)  throw cmd::ExecutionFailure(fmt::format(_("Invalid axis value: {0}"), string::to_string(axis)));
	
	// Get a shortcut to the patchcreator
	auto& patchCreator = GlobalPatchModule();

	// Create a new patch node
	scene::INodePtr node(patchCreator.createPatch(patch::PatchDefType::Def2));

	scene::INodePtr parent = sourcePatch->getParent();
	assert(parent != NULL);

	// Insert the node into the same parent as the existing patch
	parent->addChildNode(node);

	// Retrieve the contained patch from the node
	Patch* targetPatch = Node_getPatch(node);

	// Create the opposite patch with the given thickness = distance
	targetPatch->createThickenedOpposite(sourcePatch->getPatchInternal(), thickness, axis);

	// Select the newly created patch
	Node_setSelected(node, true);

	if (createSeams && thickness > 0.0f)
	{
		// Allocate four new patches
		scene::INodePtr nodes[4] = {
			patchCreator.createPatch(patch::PatchDefType::Def2),
			patchCreator.createPatch(patch::PatchDefType::Def2),
			patchCreator.createPatch(patch::PatchDefType::Def2),
			patchCreator.createPatch(patch::PatchDefType::Def2)
		};

		// Now create the four walls
		for (int i = 0; i < 4; i++)
		{
			// Retrieve the contained patch from the node
			Patch* wallPatch = Node_getPatch(nodes[i]);

			// Create the wall patch by passing i as wallIndex
			wallPatch->createThickenedWall(sourcePatch->getPatchInternal(), *targetPatch, i);

			if (!wallPatch->isDegenerate())
			{
				// Insert each node into the same parent as the existing patch
				// It's vital to do this first, otherwise these patches won't have valid shaders
				parent->addChildNode(nodes[i]);

				// Now the shader is realised, apply natural scale
				wallPatch->scaleTextureNaturally();

				// Now select the newly created patch
				Node_setSelected(nodes[i], true);
			}
			else
			{
				rMessage() << "Thicken: Discarding degenerate patch." << std::endl;
			}
		}
	}

	// Invert the target patch so that it faces the opposite direction
	targetPatch->invertMatrix();
}

void stitchTextures(const cmd::ArgumentList& args)
{
	// Get all the selected patches
	PatchPtrVector patchList = selection::algorithm::getSelectedPatches();

	if (patchList.size() == 2)
	{
		UndoableCommand undo("patchStitchTexture");

		// Fetch the instances from the selectionsystem
		auto targetNode = GlobalSelectionSystem().ultimateSelected();
		auto sourceNode = GlobalSelectionSystem().penultimateSelected();

		// Cast the instances onto a patch
		Patch* source = Node_getPatch(sourceNode);
		Patch* target = Node_getPatch(targetNode);

		if (source && target)
		{
			// Stitch the texture leaving the source patch intact
			target->stitchTextureFrom(*source);
		}
		else 
		{
			throw cmd::ExecutionFailure(_("Cannot stitch textures. \nCould not cast nodes to patches."));
		}

		SceneChangeNotify();

		// Update the Texture Tools
		radiant::TextureChangedMessage::Send();
	}
	else
	{
		throw cmd::ExecutionFailure(_("Cannot stitch patch textures. \nExactly 2 patches must be selected."));
	}
}

void bulge(const cmd::ArgumentList& args)
{
	if (args.size() != 1)
	{
		rWarning() << "Usage: BulgePatch <maxNoiseAmplitude>" << std::endl;
		return;
	}

	// Get the list of selected patches
	PatchPtrVector patches = selection::algorithm::getSelectedPatches();

	if (patches.empty())
	{
		throw cmd::ExecutionFailure(_("Cannot bulge patch. No patches selected."));
	}

	double maxValue = args[0].getDouble();

	UndoableCommand cmd("BulgePatch");

	// Cycle through all patches and apply the bulge algorithm
	for (const PatchNodePtr& p : patches)
	{
		Patch& patch = p->getPatchInternal();

		patch.undoSave();

		for (PatchControl& control : patch)
		{
			int randomNumber = int(maxValue * (float(std::rand()) / float(RAND_MAX)));
			control.vertex.set(control.vertex.x(), control.vertex.y(), control.vertex.z() + randomNumber);
		}

		patch.controlPointsChanged();
	}
}

// Adapter method, since the ODRadiant patches allows accessing the patch controls
// with row and col indices outside the control array bounds, with wrap around behaviour
inline PatchControl& getControl(IPatch& patch, int row, int col)
{
    if (col < 0 || col >= patch.getWidth() || row < 0 || row >= patch.getHeight())
    {
        return patch.ctrlAt(row % patch.getHeight(), col % patch.getWidth());
    }

    return patch.ctrlAt(row, col);
}

PatchNodePtr createdMergedPatch(const PatchNodePtr& patchNode1, const PatchNodePtr& patchNode2,
    int sourceCol1, int sourceCol2, int sourceRow1, int sourceRow2, bool invert1, bool invert2)
{
    float		s, t;
    int			col1, col2;
    int			row1, row2;
    int			adj1, adj2;
    int			in, out;
    int			w, h;

    auto& patch1 = patchNode1->getPatch();
    auto& patch2 = patchNode2->getPatch();

    auto node = GlobalPatchModule().createPatch(patch1.subdivisionsFixed() ? PatchDefType::Def3 : PatchDefType::Def2);
    auto newPatchNode = std::dynamic_pointer_cast<PatchNode>(node);
    auto& newPatch = newPatchNode->getPatch();

    newPatch.setShader(patch1.getShader());

    // Merge the patches
    if (sourceCol1 >= 0)
    {
        // Adding width
        if (sourceCol2 >= 0)
        {
            // From width
            newPatch.setDims(patch1.getWidth() + patch2.getWidth() - 1, patch1.getHeight());

            col1 = 0;
            col2 = 1;

            adj1 = 1;
            adj2 = 1;

            if (sourceCol1 != 0)
            {
                adj1 = -1;
                col1 = patch1.getWidth() - 1;
            }

            if (sourceCol2 != 0)
            {
                adj2 = -1;
                col2 = patch2.getWidth() - 2;
            }

            out = 0;

            for (w = 0; w < patch1.getWidth(); w++, col1 += adj1)
            {
                in = invert1 ? patch1.getHeight() - 1 : 0;

                for (h = 0; h < patch1.getHeight(); h++)
                {
                    getControl(newPatch, h, out) = getControl(patch1, in, col1);

                    in += invert1 ? -1 : 1;
                }

                out++;
            }

            for (w = 1; w < patch2.getWidth(); w++, col2 += adj2)
            {
                in = invert2 ? patch2.getHeight() - 1 : 0;

                for (h = 0; h < patch2.getHeight(); h++)
                {
                    getControl(newPatch, h, out) = getControl(patch2, in, col2);

                    in += invert2 ? -1 : 1;
                }

                out++;
            }
        }
        else
        {
            // From height
            newPatch.setDims(patch1.getWidth() + patch2.getHeight() - 1, patch1.getHeight());

            col1 = 0;
            row2 = 1;

            adj1 = 1;
            adj2 = 1;

            if (sourceCol1 != 0)
            {
                adj1 = -1;
                col1 = patch1.getWidth() - 1;
            }

            if (sourceRow2 != 0)
            {
                adj2 = -1;
                row2 = patch2.getHeight() - 2;
            }

            out = 0;

            for (w = 0; w < patch1.getWidth(); w++, col1 += adj1)
            {
                in = invert1 ? patch1.getHeight() - 1 : 0;

                for (h = 0; h < patch1.getHeight(); h++)
                {
                    getControl(newPatch, h, out) = getControl(patch1, in, col1);

                    in += invert1 ? -1 : 1;
                }

                out++;
            }

            for (h = 1; h < patch2.getHeight(); h++, row2 += adj2)
            {
                in = invert2 ? patch2.getWidth() - 1 : 0;

                for (w = 0; w < patch2.getWidth(); w++)
                {
                    getControl(newPatch, w, out) = getControl(patch2, row2, in);

                    in += invert2 ? -1 : 1;
                }

                out++;
            }
        }
    }
    else
    {
        // Adding height
        if (sourceRow1 >= 0)
        {
            // From height
            newPatch.setDims(patch1.getWidth(), patch1.getHeight() + patch2.getHeight() - 1);

            row1 = 0;
            row2 = 0;

            adj1 = 1;
            adj2 = 1;

            if (sourceRow1 != 0)
            {
                adj1 = -1;
                row1 = patch1.getHeight() - 1;
            }

            if (sourceRow2 != 0)
            {
                adj2 = -1;
                row2 = patch2.getHeight() - 2;
            }

            out = 0;

            for (h = 0; h < patch1.getHeight(); h++, row1 += adj1)
            {
                in = invert1 ? patch1.getWidth() - 1 : 0;

                for (w = 0; w < patch1.getWidth(); w++)
                {
                    getControl(newPatch, out, w) = getControl(patch1, row1, in);

                    in += invert1 ? -1 : 1;
                }

                out++;
            }

            for (h = 1; h < patch2.getHeight(); h++, row2 += adj2)
            {
                in = invert2 ? patch1.getWidth() - 1 : 0;

                for (w = 0; w < patch2.getWidth(); w++)
                {
                    getControl(newPatch, out, w) = getControl(patch2, row2, in);

                    in += invert1 ? -1 : 1;
                }

                out++;
            }
        }
        else
        {
            // From width
            newPatch.setDims(patch1.getWidth() + patch2.getHeight() - 1, patch1.getHeight());

            row1 = 0;
            col2 = 0;

            adj1 = 1;
            adj2 = 1;

            if (sourceRow1 != 0)
            {
                adj1 = -1;
                row1 = patch1.getHeight() - 1;
            }

            if (sourceCol2 != 0)
            {
                adj2 = -1;
                col2 = patch2.getWidth() - 2;
            }

            out = 0;

            for (h = 0; h < patch1.getHeight(); h++, row1 += adj1) 
            {
                in = invert1 ? patch1.getWidth() - 1 : 0;

                for (w = 0; w < patch1.getWidth(); w++)
                {
                    getControl(newPatch, out, w) = getControl(patch1, row1, in);

                    in += invert1 ? -1 : 1;
                }

                out++;
            }

            for (w = 1; w < patch2.getWidth(); w++, col2 += adj2)
            {
                in = invert2 ? patch1.getHeight() - 1 : 0;

                for (h = 0; h < patch2.getHeight(); h++)
                {
                    getControl(newPatch, out, h) = getControl(patch2, in, col2);

                    in += invert1 ? -1 : 1;
                }

                out++;
            }
        }
    }

    newPatch.controlPointsChanged();

    return newPatchNode;
}

namespace
{

// Returns true if all the elements in the given sequences are equal
inline bool isEqual(const PatchControlIterator& sequence1, const PatchControlIterator& sequence2)
{
    // If the iterators are invalid from the start, return false
    if (!sequence1.isValid() || !sequence2.isValid())
    {
        return false;
    }

    for (auto p1 = sequence1, p2 = sequence2; p1.isValid() && p2.isValid(); ++p1, ++p2)
    {
        if (p1->vertex != p2->vertex)
        {
            return false;
        }
    }

    return true;
}

}

PatchNodePtr createdMergedPatch(const PatchNodePtr& patchNode1, const PatchNodePtr& patchNode2)
{
    constexpr double WELD_EPSILON = 0.001;

    // Algorithm ported from ODRadiant https://svn.code.sf.net/p/odblur/code/code/OverDose%20Tools/ODRadiant/Patch.cpp) rev8348
    int		col, col1, col2;
    int		row, row1, row2;
    int		adj1, adj2;
    bool	match;

    if (patchNode1->getParent() != patchNode2->getParent())
    {
        throw cmd::ExecutionFailure(_("Patches have different parent entities, cannot weld."));
    }

    auto& patch1 = patchNode1->getPatch();
    auto& patch2 = patchNode2->getPatch();

    if (patch1.getWidth() == patch2.getWidth())
    {
        // Row dimensions match, compare the first and last row of this patch to the 
        // first and last row of the other patch
        SinglePatchRowIterator patch1FirstRow(patch1, 0);
        SinglePatchRowIterator patch1LastRow(patch1, patch1.getWidth() - 1);
        
        SinglePatchRowIterator patch2FirstRow(patch2, 0);
        SinglePatchRowIterator patch2LastRow(patch2, patch2.getWidth() - 1);

        if (isEqual(patch1FirstRow, patch2FirstRow))
        {

        }

        row1 = 0;
        row2 = 0;

        while (true)
        {
            match = false;

            col1 = 0;
            col2 = 0;

            adj1 = 0;
            adj2 = 0;

            if (getControl(patch1, row1, 0).vertex.isEqual(getControl(patch2, row2, 0).vertex, WELD_EPSILON))
            {}
            else if (getControl(patch1, row1, 0).vertex.isEqual(getControl(patch2, patch2.getWidth() - 1, row2).vertex, WELD_EPSILON))
            {
                col2 = patch2.getWidth() - 1;
                adj2 = -1;
            }
            else if (getControl(patch1, patch1.getWidth() - 1, row1).vertex.isEqual(getControl(patch2, patch2.getWidth() - 1, row2).vertex, WELD_EPSILON))
            {
                col2 = patch2.getWidth() - 1;
                adj2 = -1;

                col1 = patch1.getWidth() - 1;
                adj1 = -1;
            }
            else if (getControl(patch1, patch1.getWidth() - 1, row1).vertex.isEqual(getControl(patch2, row2, 0).vertex, WELD_EPSILON))
            {
                col1 = patch1.getWidth() - 1;
                adj1 = -1;
            }
            else
            {
                adj1 = 0;
            }

            if (adj1)
            {
                match = true;

                for (col = 0; col < patch1.getWidth(); col++, col2 += adj2, col1 += adj1)
                {
                    if (!getControl(patch1, row1, col1).vertex.isEqual(getControl(patch2, row2, col2).vertex, WELD_EPSILON))
                    {
                        match = false;
                        break;
                    }
                }
            }

            if (match)
            {
                rMessage() << "Welding row " << row1 << " with row " << row2 << std::endl;

                row1 = (row1 == 0) ? patch1.getHeight() - 1 : 0;

                return createdMergedPatch(patchNode1, patchNode2, -1, -1, row1, row2, (adj1 == -1), (adj2 == -1));
            }

            if (row2 == 0)
            {
                row2 = patch2.getHeight() - 1;
            }
            else if (row1 == 0)
            {
                row1 = patch1.getHeight() - 1;
                row2 = 0;
            }
            else
            {
                break;
            }
        }
    }

    if (patch1.getWidth() == patch2.getHeight())
    {
        row1 = 0;
        col2 = 0;

        while (1)
        {
            match = false;

            col1 = 0;
            adj1 = 1;

            row2 = 0;
            adj2 = 1;

            if (getControl(patch1, row1, 0).vertex.isEqual(getControl(patch2, 0, col2).vertex, WELD_EPSILON))
            {}
            else if (getControl(patch1, row1, 0).vertex.isEqual(getControl(patch2, patch2.getHeight() - 1, col2).vertex, WELD_EPSILON))
            {
                row2 = patch2.getHeight() - 1;
                adj2 = -1;
            }
            else if (getControl(patch1, row1, patch1.getWidth() - 1).vertex.isEqual(getControl(patch2, patch2.getHeight() - 1, col2).vertex, WELD_EPSILON))
            {
                row2 = patch2.getHeight() - 1;
                adj2 = -1;

                col1 = patch1.getWidth() - 1;
                adj1 = -1;
            }
            else if (getControl(patch1, row1, patch1.getWidth() - 1).vertex.isEqual(getControl(patch2, 0, col2).vertex, WELD_EPSILON))
            {
                col1 = patch1.getWidth() - 1;
                adj1 = -1;
            }
            else
            {
                adj1 = 0;
            }

            if (adj1)
            {
                match = true;

                for (col = 0; col < patch1.getWidth(); col++, col1 += adj1, row2 += adj2)
                {
                    if (!getControl(patch1, row1, col1).vertex.isEqual(getControl(patch2, row2, col2).vertex, WELD_EPSILON))
                    {
                        match = false;
                        break;
                    }
                }
            }

            if (match)
            {
                rMessage() << "Welding row " << row1 << " with column " << col2 << std::endl;

                row1 = (row1 == 0) ? patch1.getHeight() - 1 : 0;

                return createdMergedPatch(patchNode1, patchNode2, -1, col2, row1, -1, (adj1 == -1), (adj2 == -1));
            }

            if (col2 == 0)
            {
                col2 = patch2.getWidth() - 1;
            }
            else if (row1 == 0) 
            {
                row1 = patch1.getHeight() - 1;
                col2 = 0;
            }
            else
            {
                break;
            }
        }
    }

    if (patch1.getHeight() == patch2.getWidth())
    {
        col1 = 0;
        row2 = 0;

        while (1)
        {
            match = false;

            row1 = 0;
            adj1 = 1;

            col2 = 0;
            adj2 = 1;

            if (getControl(patch1, 0, col1).vertex.isEqual(getControl(patch2, row2, 0).vertex, WELD_EPSILON))
            {}
            else if (getControl(patch1, 0, col1).vertex.isEqual(getControl(patch2, patch2.getWidth() - 1, row2).vertex, WELD_EPSILON))
            {
                col2 = patch2.getWidth() - 1;
                adj2 = -1;
            }
            else if (getControl(patch1, patch1.getHeight() - 1, col1).vertex.isEqual(getControl(patch2, patch2.getWidth() - 1, row2).vertex, WELD_EPSILON))
            {
                col2 = patch2.getWidth() - 1;
                adj2 = -1;

                row1 = patch2.getHeight() - 1;
                adj1 = -1;
            }
            else if (getControl(patch1, patch1.getHeight() - 1, col1).vertex.isEqual(getControl(patch2, row2, 0).vertex, WELD_EPSILON))
            {
                row1 = patch2.getHeight() - 1;
                adj2 = -1;
            }
            else
            {
                adj1 = 0;
            }

            if (adj1)
            {
                match = true;

                for (row = 0; row < patch1.getHeight(); row++, row1 += adj1, col2 += adj2)
                {
                    if (!getControl(patch1, row1, col1).vertex.isEqual(getControl(patch2, row2, col2).vertex, WELD_EPSILON))
                    {
                        match = false;
                        break;
                    }
                }
            }

            if (match)
            {
                rMessage() << "Welding column " << col1 << " with row " << row2 << std::endl;

                col1 = (col1 == 0) ? patch1.getWidth() - 1 : 0;

                return createdMergedPatch(patchNode1, patchNode2, col1, -1, -1, row2, (adj1 == -1), (adj2 == -1));
            }

            if (row2 == 0)
            {
                row2 = patch2.getHeight() - 1;
            }
            else if (col1 == 0)
            {
                col1 = patch1.getWidth() - 1;
                row2 = 0;
            }
            else
            {
                break;
            }
        }
    }

    if (patch1.getHeight() == patch2.getHeight())
    {
        col1 = 0;
        col2 = 0;

        while (1) 
        {
            match = false;

            row1 = 0;
            adj1 = 1;

            row2 = 0;
            adj2 = 1;

            if (getControl(patch1, 0, col1).vertex.isEqual(getControl(patch2, 0, col2).vertex, WELD_EPSILON))
            {}
            else if (getControl(patch1, 0, col1).vertex.isEqual(getControl(patch2, patch2.getHeight() - 1, col2).vertex, WELD_EPSILON))
            {
                row2 = patch2.getHeight() - 1;
                adj2 = -1;
            }
            else if (getControl(patch1, patch1.getHeight() - 1, col1).vertex.isEqual(getControl(patch2, patch2.getHeight() - 1, col2).vertex, WELD_EPSILON))
            {
                row2 = patch2.getHeight() - 1;
                adj2 = -1;

                row1 = patch1.getHeight() - 1;
                adj1 = -1;
            }
            else if (getControl(patch1, patch1.getHeight() - 1, col1).vertex.isEqual(getControl(patch2, 0, col2).vertex, WELD_EPSILON))
            {
                row1 = patch1.getHeight() - 1;
                adj1 = -1;
            }
            else
            {
                adj1 = 0;
            }

            if (adj1)
            {
                match = true;

                for (row = 0; row < patch1.getHeight(); row++, row1 += adj1, row2 += adj2)
                {
                    if (!getControl(patch1, row1, col1).vertex.isEqual(getControl(patch2, row2, col2).vertex, WELD_EPSILON))
                    {
                        match = false;
                        break;
                    }
                }
            }

            if (match)
            {
                rMessage() << "Welding column " << col1 << " with column " << col2 << std::endl;

                col1 = (col1 == 0) ? patch1.getWidth() - 1 : 0;

                return createdMergedPatch(patchNode1, patchNode2, col1, col2, -1, -1, (adj1 == -1), (adj2 == -1));
            }

            if (col2 == 0)
            {
                col2 = patch2.getWidth() - 1;
            }
            else if (col1 == 0)
            {
                col1 = patch1.getWidth() - 1;
                col2 = 0;
            }
            else
            {
                break;
            }
        }
    }

    throw cmd::ExecutionFailure(_("Unable to weld patches, no suitable edges of same length found"));
}

void weldPatches(const PatchNodePtr& patchNode1, const PatchNodePtr& patchNode2)
{
    auto mergedPatch = createdMergedPatch(patchNode1, patchNode2);
    assert(mergedPatch);

    patchNode1->getParent()->addChildNode(mergedPatch);

    mergedPatch->assignToLayers(patchNode1->getLayers());
    // TODO: selection grouping

    mergedPatch->getPatch().scaleTextureNaturally();

    Node_setSelected(mergedPatch, true);

    scene::removeNodeFromParent(patchNode1);
    scene::removeNodeFromParent(patchNode2);
}

void weldSelectedPatches(const cmd::ArgumentList& args)
{
    if (args.size() > 0)
    {
        rWarning() << "Usage: WeldSelectedPatches" << std::endl;
        return;
    }

    // Get the list of selected patches
    auto patches = selection::algorithm::getSelectedPatches();

    if (patches.size() != 2)
    {
        throw cmd::ExecutionFailure(_("Cannot weld patches, select two patches to weld them."));
    }

    UndoableCommand cmd("WeldSelectedPatches");
    weldPatches(patches[0], patches[1]);
}

} // namespace

} // namespace