leocad/common/lc_piecedata.h

#pragma once

#include <stdio.h>
#include "lc_assettypes.h"
#include "lc_math.h"

#define LC_PIECE_NAME_LEN 256

struct lcModelPartsEntry
{
	lcMatrix44 WorldMatrix;
	const lcPieceData* PieceData;
	// Borrowed explicit mesh for generated/direct geometry; null uses PieceData->GetMesh().
	lcMesh* Mesh;
	int ColorIndex;
};

class lcSynthInfo;
class lcTrainTrackInfo;
enum class lcZipFileType;

class lcPieceData
{
public:
	explicit lcPieceData(bool IsLibraryPiece);
	~lcPieceData();

	lcPieceData(const lcPieceData&) = delete;
	lcPieceData(lcPieceData&&) = delete;
	lcPieceData& operator=(const lcPieceData&) = delete;
	lcPieceData& operator=(lcPieceData&&) = delete;

	const lcBoundingBox& GetBoundingBox() const
	{
		return mBoundingBox;
	}

	void SetBoundingBox(const lcVector3& Min, const lcVector3& Max)
	{
		mBoundingBox.Min = Min;
		mBoundingBox.Max = Max;
	}

	lcSynthInfo* GetSynthInfo() const
	{
		return mSynthInfo.get();
	}

	std::shared_ptr<const lcSynthInfo> GetSynthInfoShared() const
	{
		return mSynthInfo;
	}

	void SetSynthInfo(lcSynthInfo* SynthInfo);

	lcTrainTrackInfo* GetTrainTrackInfo() const
	{
		return mTrainTrackInfo;
	}

	void SetTrainTrackInfo(lcTrainTrackInfo* TrainTrackInfo)
	{
		mTrainTrackInfo = TrainTrackInfo;
	}

	lcMesh* GetMesh() const
	{
		return mMesh;
	}

	lcModel* GetModel() const
	{
		return mModel;
	}

	Project* GetProject() const
	{
		return mProject;
	}

	void SetMesh(lcMesh* Mesh);
	// Interactive fallback geometry is never owned by this piece or returned by GetMesh().
	lcMesh* GetDisplayMesh() const;
	void SetFailed(QString Error);
	void ReleaseMesh();

	int AddRef()
	{
		mRefCount++;
		return mRefCount;
	}

	int Release()
	{
		mRefCount--;
		return mRefCount;
	}

	int GetRefCount() const
	{
		return mRefCount;
	}

	bool IsLibraryPiece() const
	{
		return mIsLibraryPiece;
	}

	bool IsLoading() const
	{
		return mState == lcAssetState::Loading;
	}

	bool IsModel() const
	{
		return mType == Type::Model;
	}

	bool IsProject() const
	{
		return mType == Type::Project;
	}

	void SetZipFile(lcZipFileType ZipFileType, int ZipFileIndex)
	{
		mZipFileType = ZipFileType;
		mZipFileIndex = ZipFileIndex;
	}

	bool IsPatterned() const
	{
		if (!IsLibraryPiece())
			return false;

		const char* Name = mFileName;

		// Heuristic: Names matching '^[Uu]?[0-9]*[A-Za-z][^.][^.]' are patterned.

		if (*Name == 'U' || *Name == 'u')
			Name++;

		while (*Name)
		{
			if (*Name < '0' || *Name > '9')
				break;

			Name++;
		}

		if (!*Name || !((*Name >= 'A' && *Name <= 'Z') || (*Name >= 'a' && *Name <= 'z')))
			return false;

		if (Name[1] && Name[1] != '.' && Name[2] && Name[2] != '.')
			return true;

		return false;
	}

	bool IsSubPiece() const
	{
		return (m_strDescription[0] == '~');
	}

	bool IsProjectPiece() const;
	void ZoomExtents(float FoV, float AspectRatio, lcMatrix44& ProjectionMatrix, lcMatrix44& ViewMatrix) const;
	void AddRenderMesh(lcScene& Scene);
	void AddRenderMeshes(lcScene* Scene, const lcMatrix44& WorldMatrix, int ColorIndex, lcRenderMeshState RenderMeshState, bool ParentActive) const;

	void CreatePart(const char* Name);

	void DetachContainer();
	void SetModel(lcModel* Model);
	void CreateProject(Project* Project, const char* PieceName);
	bool GetPieceWorldMatrix(lcPiece* Piece, lcMatrix44& WorldMatrix) const;
	bool IncludesModel(const lcModel* Model) const;
	bool MinIntersectDist(const lcVector3& Start, const lcVector3& End, float& MinDistance, lcPieceRayTest& PieceRayTest) const;
	bool BoxTest(const lcMatrix44& WorldMatrix, const lcVector4 Planes[6]) const;
	void GetPartsList(int DefaultColorIndex, bool ScanSubModels, bool AddSubModels, lcPartsList& PartsList) const;
	void GetModelParts(const lcMatrix44& WorldMatrix, int DefaultColorIndex, std::vector<lcModelPartsEntry>& ModelParts) const;
	void CompareBoundingBox(const lcMatrix44& WorldMatrix, lcVector3& Min, lcVector3& Max) const;
	void AddSubModelBoundingBoxPoints(const lcMatrix44& WorldMatrix, std::vector<lcVector3>& Points, lcGeometryBoundsMode Mode) const;
	void UpdateBoundingBox(std::vector<lcModel*>& UpdatedModels);

	void Unload();

public:
	char mFileName[LC_PIECE_NAME_LEN];
	char m_strDescription[256];
	lcZipFileType mZipFileType;
	int mZipFileIndex;
	lcAssetState mState;
	int mFolderType;
	int mFolderIndex;

protected:
	enum class Type
	{
		Part,
		Model,
		Project
	};

	void SetLoadingBoundingBox();

	// Fixed at creation, independently of type and load state.
	const bool mIsLibraryPiece;
	int mRefCount = 0;
	Type mType = Type::Part;
	lcModel* mModel = nullptr;
	Project* mProject = nullptr;
	lcMesh* mMesh = nullptr;
	lcBoundingBox mBoundingBox;
	std::shared_ptr<lcSynthInfo> mSynthInfo;
	lcTrainTrackInfo* mTrainTrackInfo = nullptr;
};