path: root/hammer/mapface.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#ifndef MAPFACE_H
#define MAPFACE_H

#ifdef _WIN32
#pragma once
#endif


#pragma warning(push, 1)
#pragma warning(disable:4701 4702 4530)
#include <fstream>
#pragma warning(pop)
#include "hammer_mathlib.h"
#include "MapAtom.h"
#include "DispManager.h"
#include "mathlib/Vector4d.h"
#include "utlvector.h"
#include "Color.h"
#include "smoothinggroupmgr.h"
#include "detailobjects.h"

class CCheckFaceInfo;
class IEditorTexture;
class CRender;
class CRender3D;
class CChunkFile;
class CSaveInfo;
class IMaterial;
class CMapWorld;
struct MapFaceRender_t;
class CMeshBuilder;
class IMesh;

struct LoadFace_t;

enum EditorRenderMode_t;
enum ChunkFileResult_t;

#define DEFAULT_TEXTURE_SCALE			0.25
#define DEFAULT_LIGHTMAP_SCALE			16

#define SMOOTHING_GROUP_MAX_COUNT		32
#define SMOOTHING_GROUP_DEFAULT			0

//
// Flags for CMapFace::CopyFrom.
//
#define COPY_FACE_PLANE			0x00000001			// Copies only the face's plane. Used for carving.
#define COPY_FACE_POINTS		0x00000002			// Copies the face's points and plane.


//
// Used for storing the extrema of a face. Each element of the Extents_t array
// contains a point that represents a local extreme along a particular dimension.
//
enum
{
	EXTENTS_XMIN = 0,
	EXTENTS_XMAX,
	EXTENTS_YMIN,
	EXTENTS_YMAX,
	EXTENTS_ZMIN,
	EXTENTS_ZMAX,
	NUM_EXTENTS_DIMS,
};

typedef Vector Extents_t[NUM_EXTENTS_DIMS];


struct PLANE
{
	Vector		normal;
	float		dist;
	Vector		planepts[3];
};


typedef struct
{
	int		numpoints;
	Vector	*p;			// variable sized
} winding_t;


enum FaceOrientation_t
{
	FACE_ORIENTATION_FLOOR = 0,
	FACE_ORIENTATION_CEILING,
	FACE_ORIENTATION_NORTH_WALL,
	FACE_ORIENTATION_SOUTH_WALL,
	FACE_ORIENTATION_EAST_WALL,
	FACE_ORIENTATION_WEST_WALL,
	FACE_ORIENTATION_INVALID
};


//
// Both an enumeration and bitflags. Used as bitflags when querying a face for its texture
// alignment because it could be world aligned and face aligned at the same time.
//
enum TextureAlignment_t
{
	TEXTURE_ALIGN_NONE	= 0x0000,
	TEXTURE_ALIGN_WORLD = 0x0001,
	TEXTURE_ALIGN_FACE	= 0x0002,
	TEXTURE_ALIGN_QUAKE = 0x0004
};


enum TextureJustification_t
{
	TEXTURE_JUSTIFY_NONE = 0,
	TEXTURE_JUSTIFY_TOP,
	TEXTURE_JUSTIFY_BOTTOM,
	TEXTURE_JUSTIFY_LEFT,
	TEXTURE_JUSTIFY_CENTER,
	TEXTURE_JUSTIFY_RIGHT,
	TEXTURE_JUSTIFY_FIT,
	TEXTURE_JUSTIFY_MAX
};


#define INIT_TEXTURE_FORCE			0x0001
#define INIT_TEXTURE_AXES			0x0002
#define INIT_TEXTURE_ROTATION		0x0004
#define INIT_TEXTURE_SHIFT			0x0008
#define INIT_TEXTURE_SCALE			0x0010
#define INIT_TEXTURE_ALL			(INIT_TEXTURE_AXES | INIT_TEXTURE_ROTATION | INIT_TEXTURE_SHIFT | INIT_TEXTURE_SCALE)


//
// Flags for CreateFace.
//
#define CREATE_FACE_PRESERVE_PLANE	0x0001		// Hack to prevent plane from being recalculated while building a solid from its planes.
#define CREATE_FACE_CLIPPING		0x0002

//
// Serialized data structure. Do not modify!
//
struct TEXTURE_21
{
	char	texture[MAX_PATH];
	float	rotate;
	float	shift[2];
	float	scale[2];
	BYTE	smooth;
	BYTE	material;
	DWORD	q2surface;
	DWORD	q2contents;
	DWORD	q2value;
};


//
// Post 2.1 explicit texture U/V axes were added.
//
// Serialized data structure. Do not modify!
//
struct TEXTURE_33
{
	char texture[MAX_PATH];
	float UAxis[4];				// Must remain float[4] for RMF serialization.
	float VAxis[4];				// Must remain float[4] for RMF serialization.
	float rotate;
	float scale[2];
	BYTE smooth;
	BYTE material;
	DWORD q2surface;
	DWORD q2contents;
	int nLightmapScale;
};


struct TEXTURE
{
	char texture[MAX_PATH];
	Vector4D UAxis;
	Vector4D VAxis;
	float rotate;
	float scale[2];
	BYTE smooth;
	BYTE material;
	DWORD q2surface;
	DWORD q2contents;
	int nLightmapScale;

	TEXTURE& operator=( TEXTURE const& src )
	{
		// necessary since operator= is private for UAxis
		memcpy( this, &src, sizeof(TEXTURE) );
		return *this;
	}
};


#define FACE_FLAGS_NOSHADOW 1
#define FACE_FLAGS_NODRAW_IN_LPREVIEW 2



class CMapFace : public CMapAtom
{
public:

	CMapFace(void);
	~CMapFace(void);

	// If bRescaleTextureCoordinates is true, then it will rescale and reoffset the texture coordinates
	// so that the texture is in the same apparent spot as the old texture (if they are different sizes).
	void SetTexture(const char *pszNewTex, bool bRescaleTextureCoordinates = false);
	void SetTexture(IEditorTexture *pTexture, bool bRescaleTextureCoordinates = false);
	void GetTextureName(char *pszName) const;

	inline IEditorTexture *GetTexture(void) const;
		
	// Renders opaque faces
	static void			AddFaceToQueue( CMapFace* pMapFace, IEditorTexture* pTexture, EditorRenderMode_t renderMode, bool selected, SelectionState_t faceSelectionState );
	static void			PushFaceQueue( void );
	static void			PopFaceQueue( void );
	static void			RenderOpaqueFaces( CRender3D* pRender );

	//
	// Serialization.
	//
	ChunkFileResult_t LoadVMF(CChunkFile *pFile);
	ChunkFileResult_t SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo);
	int SerializeRMF(std::fstream&, BOOL);
	int SerializeMAP(std::fstream&, BOOL);

	BOOL CheckFace(CCheckFaceInfo* = NULL);
	BOOL Fix(void);

	float GetNormalDistance(Vector& fPoint);

	inline int GetPointCount(void);
	inline void GetPoint(Vector& Point, int nPoint);

	inline void GetLightmapCoord( Vector2D & LightmapCoord, int nIndex );
	inline void SetLightmapCoord( const Vector2D &LightmapCoord, int nIndex );
	inline void GetTexCoord( Vector2D & TexCoord, int nTexCoord );

	// Texture alignment.
	void GetCenter(Vector& Center);
	FaceOrientation_t GetOrientation(void) const;
	void RotateTextureAxes(float fDegrees);
	void InitializeTextureAxes(TextureAlignment_t eAlignment, DWORD dwFlags);
	void JustifyTexture(TextureJustification_t eJustification);
	void JustifyTextureUsingExtents(TextureJustification_t eJustification, Extents_t Extents);
	void GetFaceBounds(Vector& pfMins, Vector& pfMaxs) const;
	void GetFaceExtents(Extents_t Extents) const;
	void GetTextureExtents(Extents_t Extents, Vector2D & TopLeft, Vector2D & BottomRight) const;
	int GetTextureAlignment(void) const;
	void GetFaceTextureExtents(Vector2D & TopLeft, Vector2D & BottomRight) const;

	void CalcTextureCoordAtPoint( const Vector& pt, Vector2D & texCoord );
	void CalcLightmapCoordAtPoint( const Vector& pt, Vector2D & lightCoord );

	// Returns the max lightmap size for this face
	int MaxLightmapSize() const;

	void NormalizeTextureShifts(void);
	BOOL IsTextureAxisValid(void) const;

	inline void SetCordonFace( bool bCordonFace );
	inline bool IsCordonFace() const;

	// Old code for setting up texture axes. Needed for backwards compatibility.
	void InitializeQuakeStyleTextureAxes(Vector4D& UAxis, Vector4D& VAxis);

	void CreateFace(Vector *pPoints, int nPoints, bool bIsCordonFace = false);
	void CreateFace(winding_t *w, int nFlags = 0);
	CMapFace *CopyFrom(const CMapFace *pFrom, DWORD dwFlags = COPY_FACE_POINTS, bool bUpdateDependencies = true );
	size_t AllocatePoints(int nPoints);

	void OnUndoRedo();

	void CalcPlane(void);
	void CalcPlaneFromFacePoints(void);

	void CalcTextureCoords();
	void OffsetTexture(const Vector &Delta);
	void SetTextureCoords(int nPoint, float u, float v);

	struct TangentSpaceAxes_t
	{
		Vector	tangent;
		Vector	binormal;
	};
		
	void CalcTangentSpaceAxes( void );
	bool AllocTangentSpaceAxes( int count );
	void FreeTangentSpaceAxes( void );

	void Render2D(CRender2D *pRender);
	void Render3D(CRender3D *pRender);
	void Render3DGrid(CRender3D *pRender);
	void RenderVertices(CRender *pRender);

	void OnAddToWorld(CMapWorld *pWorld);
	void OnRemoveFromWorld(void);

	static void SetShowSelection(bool bShowSelection);

	inline void SetRenderAlpha(unsigned char uchAlpha) { m_uchAlpha = uchAlpha; } // HACK: should be in CMapAtom

	inline void GetFaceNormal( Vector& normal );
	bool TraceLine(Vector &HitPos, Vector &HitNormal, Vector const &Start, Vector const &End);
	bool TraceLineInside( Vector &HitPos, Vector &HitNormal, Vector const &Start, Vector const &End, bool bNoDisp = false );

	inline void SetDisp( EditDispHandle_t handle, bool bDestroyPrevious = true );
	inline EditDispHandle_t GetDisp( void );
	inline bool HasDisp( void ) const;

	bool ShouldRenderLast();
	void GetDownVector( int index, Vector& downVect );

	bool GetRender2DBox( Vector& boundMin, Vector& boundMax );
	bool GetCullBox( Vector& boundMin, Vector& boundMax );
	size_t GetDataSize( void );

	inline int GetFaceID(void);
	inline void SetFaceID(int nFaceID);

	// Smoothing group.
	int SmoothingGroupCount( void );
	void AddSmoothingGroup( int iGroup );
	void RemoveSmoothingGroup( int iGroup );
	bool InSmoothingGroup( int iGroup );

	// Indicates this guy should be unlit
	void RenderUnlit( bool enable );

	// (begin serialized information
	TEXTURE texture;					// Texture info.
	Vector *Points;						// Array of face points, dynamically allocated.
	int	nPoints;						// The number of points in the array.
	// end serialized information)

	PLANE plane;

	int m_nFaceFlags;										// FACE_FLAGS_xx

	void DoTransform(const VMatrix &matrix);

	virtual void AddShadowingTriangles( CUtlVector<Vector> &tri_list );

	DetailObjects		*m_pDetailObjects;
	
protected:

	void ComputeColor( CRender3D* pRender, bool bRenderAsSelected, SelectionState_t faceSelectionState,
					   bool ignoreLighting, Color &pColor );

	void DrawFace( Color &pColor, EditorRenderMode_t mode );
	void RenderGridIfCloseEnough( CRender3D* pRender );
	void RenderTextureAxes( CRender3D* pRender );

	// Adds a face's vertices to the meshbuilder
	void AddFaceVertices( CMeshBuilder &builder, CRender3D* pRender, bool bRenderSelected, SelectionState_t faceSelectionState );

	// render texture axes
	static void RenderTextureAxes( CRender3D* pRender, int nCount, CMapFace **ppFaces );
	static void RenderGridsIfCloseEnough( CRender3D* pRender, int nCount, CMapFace **ppFaces );
	static void Render3DGrids( CRender3D* pRender, int nCount, CMapFace **ppFaces );
	static void RenderWireframeFaces( CRender3D* pRender, int nCount, MapFaceRender_t **ppFaces );
	static void RenderFacesBatch( CMeshBuilder &MeshBuilder, IMesh* pMesh, CRender3D* pRender, MapFaceRender_t **ppFaces, int nFaceCount, int nVertexCount, int nIndexCount, bool bWireframe );
	static void RenderFaces( CRender3D* pRender, int nCount, MapFaceRender_t **ppFaces );

	void RenderFace3D( CRender3D* pRender, EditorRenderMode_t renderMode, bool renderSelected, SelectionState_t faceSelectionState );

	//
	// Serialization (chunk handlers).
	//
	static ChunkFileResult_t LoadDispInfoCallback(CChunkFile *pFile, CMapFace *pFace);
	static ChunkFileResult_t LoadKeyCallback(const char *szKey, const char *szValue, LoadFace_t *pLoadFace);

	unsigned char m_uchAlpha;			// HACK: should be in CMapAtom

	int m_nFaceID;						// The unique ID of this face in the world.

	IEditorTexture *m_pTexture;				// Texture that is applied to this face.
	static IEditorTexture *m_pLightmapGrid;	// Lightmap grid texture for use in viewing lightmap scales.
	EditDispHandle_t	m_DispHandle;			// Displacement map applied to this face, NULL if none.

	static bool m_bShowFaceSelection;	// Whether to render faces with a special color when they are selected.

	Vector2D *m_pTextureCoords;			// An array of texture coordinates, one per face point.
	Vector2D *m_pLightmapCoords;			// An array of lightmap coordinates, one per face point.

	bool m_bIsCordonFace : 1;

	// should this be affected by lighting?
	bool m_bIgnoreLighting : 1;

	TangentSpaceAxes_t	*m_pTangentAxes;

	unsigned int		m_fSmoothingGroups;		// 32-bits representing 32 smoothing groups

	void UpdateFaceFlags( void );							// sniff face flags from texture
};


//-----------------------------------------------------------------------------
// Purpose: Returns the unique ID of this face.
//-----------------------------------------------------------------------------
inline int CMapFace::GetFaceID(void)
{
	return(m_nFaceID);
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : TexCoord - 
//			nTexCoord - 
//-----------------------------------------------------------------------------
inline void CMapFace::GetLightmapCoord( Vector2D& LightmapCoord, int nIndex )
{
    Assert( nIndex < nPoints );
    LightmapCoord[0] = m_pLightmapCoords[nIndex][0];
    LightmapCoord[1] = m_pLightmapCoords[nIndex][1];
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &LightmapCoord - 
//			nIndex - 
// Output : inline void
//-----------------------------------------------------------------------------
inline void CMapFace::SetLightmapCoord( const Vector2D &LightmapCoord, int nIndex )
{
    Assert( nIndex < nPoints );
	m_pLightmapCoords[nIndex][0] = LightmapCoord[0];
	m_pLightmapCoords[nIndex][1] = LightmapCoord[1];
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : TexCoord - 
//			nTexCoord - 
//-----------------------------------------------------------------------------
inline void CMapFace::GetTexCoord( Vector2D& TexCoord, int nTexCoord )
{
    Assert( nTexCoord < nPoints );
    TexCoord[0] = m_pTextureCoords[nTexCoord][0];
    TexCoord[1] = m_pTextureCoords[nTexCoord][1];
}


//-----------------------------------------------------------------------------
// Purpose: Returns a pointer to the texture that is applied to this face, NULL if none.
//-----------------------------------------------------------------------------
inline IEditorTexture *CMapFace::GetTexture(void) const
{
	return(m_pTexture);
}


//-----------------------------------------------------------------------------
// Purpose: Returns the number of vertices that define this face.
//-----------------------------------------------------------------------------
inline int CMapFace::GetPointCount(void)
{
	return(nPoints);
}


//-----------------------------------------------------------------------------
// Purpose: Retrieves a point on this face by its index.
// Input  : Point - Receives point coordinates.
//			nPoint - Index of point to retrieve.
//-----------------------------------------------------------------------------
inline void CMapFace::GetPoint(Vector& Point, int nPoint)
{
	Assert(nPoint < nPoints);
	Point = Points[nPoint];
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapFace::GetFaceNormal( Vector& normal )
{
	normal = plane.normal;
}


//-----------------------------------------------------------------------------
// Purpose: Sets the unique ID of this face.
//-----------------------------------------------------------------------------
inline void CMapFace::SetFaceID(int nID)
{
	m_nFaceID = nID;
}


//-----------------------------------------------------------------------------
// Purpose: Attaches a displacement surface to this face.
// Input  : handle - Displacement surface handle of surface attached to this face
//-----------------------------------------------------------------------------
inline void CMapFace::SetDisp( EditDispHandle_t handle, bool bDestroyPrevious )
{
	if ( ( m_DispHandle != EDITDISPHANDLE_INVALID ) && bDestroyPrevious )
	{
		// destroy old handle
		EditDispMgr()->Destroy( m_DispHandle );
	}
		
	Assert( ( handle == EDITDISPHANDLE_INVALID ) || ( EditDispMgr()->GetDisp( handle ) != NULL ) );

	m_DispHandle = handle;
}


//-----------------------------------------------------------------------------
// Purpose: Returns the displacement surface applied to this face, 
//          DISPHANDLE_INVALID if none.
//-----------------------------------------------------------------------------
inline EditDispHandle_t CMapFace::GetDisp( void )
{
    return m_DispHandle;
}


//-----------------------------------------------------------------------------
// Purpose: Returns true if this face has a displacement surface, false if not.
//-----------------------------------------------------------------------------
inline bool CMapFace::HasDisp( void ) const
{
	return ( m_DispHandle != EDITDISPHANDLE_INVALID );
}


//-----------------------------------------------------------------------------
// Whether this face belongs to a cordon brush.
//-----------------------------------------------------------------------------
inline void CMapFace::SetCordonFace( bool bCordonFace )
{
	m_bIsCordonFace = bCordonFace;
}


inline bool CMapFace::IsCordonFace() const
{
	return m_bIsCordonFace;
}


//-----------------------------------------------------------------------------
// Defines a container class for a list of face pointers.
//-----------------------------------------------------------------------------
class CMapFaceList : public CUtlVector<CMapFace *>
{
public:

	inline CMapFaceList(void) {}
	inline CMapFaceList(CMapFaceList const &other);
	inline CMapFaceList &CMapFaceList::operator =(CMapFaceList const &other);

	inline int FindFaceID(int nFaceID);
	void Intersect(CMapFaceList &IntersectWith, CMapFaceList &In, CMapFaceList &Out);
};


//-----------------------------------------------------------------------------
// Purpose: Copy constructor.
//-----------------------------------------------------------------------------
CMapFaceList::CMapFaceList(CMapFaceList const &other)
{
	*this = other;
}


//-----------------------------------------------------------------------------
// Purpose: Assignment operator for copying face lists.
// Input  : other - 
//-----------------------------------------------------------------------------
CMapFaceList &CMapFaceList::operator =(CMapFaceList const &other)
{
	AddVectorToTail(other);
	return *this;
}


//-----------------------------------------------------------------------------
// Purpose: Searches the list for a face with the given ID.
// Input  : nFaceID - Numeric face ID to search for.
// Output : Index of found element, -1 if none.
//-----------------------------------------------------------------------------
int CMapFaceList::FindFaceID(int nFaceID)
{
	for (int i = 0; i < Count(); i++)
	{
		if ((Element(i) != NULL) && (Element(i)->GetFaceID() == nFaceID))
		{
			return(i);
		}
	}

	return(-1);
}


//-----------------------------------------------------------------------------
// Defines a container class for a list of face IDs.
//-----------------------------------------------------------------------------
class CMapFaceIDList : public CUtlVector<int>
{
public:

	inline CMapFaceIDList(void) {}
	inline CMapFaceIDList(CMapFaceIDList const &other);
	inline CMapFaceIDList &CMapFaceIDList::operator =(CMapFaceIDList const &other);

	void Intersect(CMapFaceIDList &IntersectWith, CMapFaceIDList &In, CMapFaceIDList &Out);
};


//-----------------------------------------------------------------------------
// Purpose: Copy constructor.
//-----------------------------------------------------------------------------
CMapFaceIDList::CMapFaceIDList(CMapFaceIDList const &other)
{
	*this = other;
}


//-----------------------------------------------------------------------------
// Purpose: Assignment operator for copying face ID lists.
// Input  : other - 
//-----------------------------------------------------------------------------
CMapFaceIDList &CMapFaceIDList::operator =(CMapFaceIDList const &other)
{
	AddVectorToTail(other);
	return *this;
}


#endif // MAPFACE_H