CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxConvert/plLightMapGen.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#ifndef plLightMapGen_inc
#define plLightMapGen_inc

#include "hsTemplates.h"

#include <vector>

class plMaxLightContext;
class plRenderGlobalContext;
class plLayerInterface;
class plMaxNode;
class hsGMaterial;
class plGeometrySpan;
class plMipmap;
class plBitmap;
struct hsColorRGBA;
struct hsPoint3;
struct hsVector3;
struct hsMatrix44;
class plErrorMsg;
class plConvertSettings;
class hsBounds3Ext;
class plLightMapComponent;

class plLightMapInfo
{
public:
	ObjLightDesc*		fObjLiDesc;
	INode*				fLiNode;
	int					fResetShadowType;
	float				fResetMapRange;
	float				fMapRange;
	hsBool				fNewRender;
};

class plLightMapGen
{
protected:
	Interface*					fInterface;
	TimeValue					fTime;

	int							fUVWSrc;
	float						fScale;

	float						fMapRange;
	
	int							fWidth;
	int							fHeight;

	bool						fRecalcLightMaps;

	Renderer*					fRenderer;
#ifdef MF_NEW_RGC
	RenderGlobalContext*		fRGC;
#else // MF_NEW_RGC
	plRenderGlobalContext*		fRGC;
#endif // MF_NEW_RGC
	RendParams*					fRP;
	
	hsTArray<plLightMapInfo>	fAllLights;
	hsTArray<plLightMapInfo*>	fActiveLights;

	mutable hsTArray<plLayerInterface*>	fCreatedLayers;
	mutable hsTArray<plMipmap*>			fPreppedMipmaps;

	mutable hsTArray<plBitmap*> fNewMaps;	// Mipmaps created this session (not loaded from disk)

	std::vector<plLightMapComponent*> fSharedComponents; // HACK so we can get rid of key refs before deleting bitmaps

	hsBounds3Ext	IGetBoundsLightSpace(INode* node, INode* liNode);
	hsBool			IDirAffectsNode(plLightMapInfo* liInfo, LightObject* liObj, INode* node);
	hsBool			ISpotAffectsNode(plLightMapInfo* liInfo, LightObject* liObj, INode* node);
	hsBool			IOmniAffectsNode(plLightMapInfo* liInfo, LightObject* liObj, INode* node);
	hsBool			ILightAffectsNode(plLightMapInfo* liInfo, LightObject* liObj, INode* node);

	hsBool		IPrepLight(plLightMapInfo* liInfo, INode* node);
	hsBool		IGetLight(INode* node);
	hsBool		IFindLightsRecur(INode* node);
	hsBool		IFindActiveLights(plMaxNode* node);
	hsBool		IReleaseActiveLights();
	hsBool		IReleaseAllLights();

	int			IPowerOfTwo(int sz) const;
	hsBool		ISelectBitmapDimension(plMaxNode* node, const hsMatrix44& l2w, const hsMatrix44& w2l, hsTArray<plGeometrySpan *> &spans);
	hsBool		ICompressLightMaps();
	
	hsBool		IsFresh(plBitmap* map) const;

	hsBool				IAddToLightMap(plLayerInterface* lay, plMipmap* src) const;
	plMipmap*			IMakeAccumBitmap(plLayerInterface* lay) const;
	void				IInitBitmapColor(plMipmap* bitmap, const hsColorRGBA& col) const;
	plLayerInterface*	IGetLightMapLayer(plMaxNode* node, plGeometrySpan& span);
	plLayerInterface*	IMakeLightMapLayer(plMaxNode* node, plGeometrySpan& span);
	int					IGetUVWSrc() const { return fUVWSrc; }

	UInt32		IShadePoint(plMaxLightContext& ctx, const Color& amb, const hsPoint3& p, const hsVector3& n);
	hsBool		IShadeVerts(plMaxLightContext& ctx, const Color& amb, const hsPoint3 pt[3], const hsVector3 norm[3], const hsPoint3 uv[3], plMipmap* bitmap);
	hsBool		IShadeFace(plMaxNode* node, const hsMatrix44& l2w, const hsMatrix44& w2l, plGeometrySpan& span, int iFace, plMipmap* bitmap);
	hsBool		IShadeSpan(plMaxNode* node, const hsMatrix44& l2w, const hsMatrix44& w2l, plGeometrySpan& spans);
	hsBool		IShadeGeometrySpans(plMaxNode* node, const hsMatrix44& l2w, const hsMatrix44& w2l, hsTArray<plGeometrySpan *> &spans);

	hsBool		IWantsMaps(plMaxNode* node);
	hsBool		IValidateUVWSrc(hsTArray<plGeometrySpan *> &spans) const;

public:
	plLightMapGen();
	virtual ~plLightMapGen();

#ifdef MF_NEW_RGC
	void SetRGC(RenderGlobalContext* rgc); // Don't call this ever ever ever
#endif // MF_NEW_RGC

	hsBool		Open(Interface* ip, TimeValue t, bool forceRegen=true);
	hsBool		InitNode(INode* node, hsBool softShadow=true); // unnecessary when using MakeMaps()
	hsBool		Update(TimeValue t);

	void SetUVWSrc(int i) { fUVWSrc = i; }
	int GetUVWSrc() const { return fUVWSrc; }

	void SetScale(float f) { fScale = f; }
	float GetScale() const { return fScale; }

	// Calls to either the global or single must be wrapped in
	// a call to Open and a call to close. That is, you must first
	// call Open(), then you can make maps all day, but at the end
	// of the day, you need to call Close(). Also, if the scene
	// lighting changes, you need to call Close() and then Open() again.
	// With the possibility of lights getting deleted from the scene,
	// you're best off calling Open(), making as many maps as you want
	// for now, call Close(), and if you decide later you want more,
	// re-open. There's no protection in here from a user deleting
	// a light (or any other node) while the shader is Open. For your
	// own safety and the safety of your fellow passengers, don't
	// return control to the user until the system is Closed.
	hsBool		MakeMaps(plMaxNode* node, const hsMatrix44& l2w, const hsMatrix44& w2l, hsTArray<plGeometrySpan *>& spans, plErrorMsg *pErrMsg, plConvertSettings *settings);

	Color		ShadowPoint(plMaxLightContext& ctx);
	Color		ShadePoint(plMaxLightContext& ctx); // ctx already contains pos & norm
	Color		ShadePoint(plMaxLightContext& ctx, const Point3& p, const Point3& n);
	Color		ShadePoint(plMaxLightContext& ctx, const hsPoint3& p, const hsVector3& n);

	hsBool		DeInitNode();
	hsBool		Close();

	static plLightMapGen& Instance();
};

#endif // plLightMapGen_inc