/*
 * Copyright (c) 2016-2022 Vera Visions LLC.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

/*QUAKED env_fog_controller (1 0 0) (-8 -8 -8) (8 8 8) EVFOGCTL_MASTER
Textured light projected. This is the type of lighting that's used for
flashlights, lamp spotlights and so on.

-------- KEYS --------
"targetname" : Name
"target" : Name of an entity in the map that light will point at.
"fogenable" : Will make the fog start active if not 0.
"fogstart" : Distance from the camera of where the fog starts.
"fogend" : Distance from the camera of where the fog ends.
"fogmaxdensity" : Maximum fog density. Value between 0.00 and 1.00.
"farz" : Clip anything after the specified distance.
"fogcolor" : Primary color of the fog in RGB255. E.g. '255 0 0' for red.
"fogcolor2" : Secondary color of the fog in RGB255. Only used when 'fogblend' is 1.
"fogblend" : Whether or not to blend between fogcolor and fogcolor2.
"fogdir" : The fog directon for the secondary color. Only used when 'fogblend' is 1.
"use_angles" : If we should use the 'angles' key instead of 'fogdir'. Only used when 'fogblend' is 1.

-------- INPUTS --------
"TurnOff" : Turns the entity off.
"TurnOn" : Turns the entity on.
"Toggle" : Toggles the entity to an on/off state.
"SetStartDist" : Sets fogstart.
"SetEndDist" : Sets fogend.
"SetColor" : Sets fogcolor.
"SetColorSecondary" : Sets fogcolor2.
"SetFarZ" : Sets farz.

-------- SPAWNFLAGS --------
EVFOGCTL_MASTER : If specified, this one will always take priority over
                  any other active fog controllers... currently unused.

-------- TRIVIA --------
This entity was introduced in Half-Life 2 (2004).
*/

enumflags
{
	ENVFOG_CHANGED_ACTIVE,
	ENVFOG_CHANGED_BLEND,
	ENVFOG_CHANGED_START,
	ENVFOG_CHANGED_END,
	ENVFOG_CHANGED_MAXDENSITY,
	ENVFOG_CHANGED_FARZ,
	ENVFOG_CHANGED_COLOR,
	ENVFOG_CHANGED_COLOR2,
	ENVFOG_CHANGED_DIR
};

class
env_fog_controller:NSPointTrigger
{
	/* networked attributes */
	PREDICTED_INT(m_iFogActive)
	PREDICTED_INT(m_iFogBlend)
	PREDICTED_FLOAT(m_flFogStart)
	PREDICTED_FLOAT(m_flFogEnd)
	PREDICTED_FLOAT(m_flFogMaxDensity)
	PREDICTED_FLOAT(m_flFogFarZ)
	PREDICTED_VECTOR(m_vecFogColor)
	PREDICTED_VECTOR(m_vecFogColor2)
	PREDICTED_VECTOR(m_vecFogDir)

	void(void) env_fog_controller;

#ifdef CLIENT
	/* temporary attributes */
	float m_flNextDraw;
	float m_flLastDelta;

	virtual float(void) StartToBias;
	virtual float(void) FogRender;
	virtual void(void) FogUpdate;
	virtual void(void) RendererRestarted;
	virtual void(float,float) ReceiveEntity;
#else
	/* main spawn attributes */
	int m_iSpawnEnable;
	int m_iSpawnBlend;
	float m_flSpawnStart;
	float m_flSpawnEnd;
	float m_flSpawnMaxDensity;
	float m_flSpawnFarZ;
	vector m_vecSpawnColor;
	vector m_vecSpawnColor2;
	vector m_vecSpawnDir;
	int m_iUseAngles;

	virtual float(entity, float) SendEntity;
	virtual void(void) EvaluateEntity;
	virtual void(entity, int) Trigger;
	virtual void(void) Respawn;
	virtual void(float) Save;
	virtual void(string,string) Restore;
	virtual void(entity, string, string) Input;
	virtual void(string, string) SpawnKey;
#endif
};

#ifdef CLIENT
float
env_fog_controller::StartToBias(void)
{
	/* FIXME: currently we don't convert fogstart and fogend into density and bias at all. */
	if (m_flFogStart < 256)
		return 0.2;
	else if (m_flFogStart < 512)
		return 0.1;
	else if (m_flFogStart < 1024)
		return 0.05;
	else if (m_flFogStart < 2048)
		return 0.025;
	else if (m_flFogStart < 4096)
		return 0.0175;
	else
		return 0.05;
}

/* this is mainly for the 'blended' fog. Which is more expensive. */
float
env_fog_controller::FogRender(void)
{
	vector p1, p2;

	if (!m_iFogActive)
		return (PREDRAW_NEXT);

	CSQC_UpdateSeat();

	/* get the difference between camera dir and fog dir */
	makevectors(m_vecFogDir);
	p1 = v_forward;
	makevectors(getproperty(VF_CL_VIEWANGLES));
	p2 = v_forward;
	float delta = vlen(p1 - p2) / 2.0f;

	/* cache so we don't call 'fog' every frame */
	if (delta == m_flLastDelta)
		return (PREDRAW_NEXT);

	m_flLastDelta = delta;

	/* we also only need to call this maybe once every second... */
	if (m_flNextDraw > cltime)
		return (PREDRAW_NEXT);

	m_flNextDraw = cltime + 1.0f;

	/* apply the fog. wish there was a builtin for this instead... */
	localcmd(sprintf("fog %f %f %f %f %f %f\n", \
		StartToBias(),
		Math_Lerp(m_vecFogColor[0], m_vecFogColor2[0], delta),
		Math_Lerp(m_vecFogColor[1], m_vecFogColor2[1], delta),
		Math_Lerp(m_vecFogColor[2], m_vecFogColor2[2], delta),
		m_flFogMaxDensity,
		0.0f));

	//print(sprintf("%f (%v, %v)\n", delta, p1, p2));

	return (PREDRAW_NEXT);
}

void
env_fog_controller::FogUpdate(void)
{
	if (!m_iFogActive)
		return;

	localcmd(sprintf("fog %f %f %f %f %f %f\n", \
		StartToBias(),
		m_vecFogColor[0],
		m_vecFogColor[1],
		m_vecFogColor[2],
		m_flFogMaxDensity,
		0.0f));
}

void
env_fog_controller::RendererRestarted(void)
{
	think = FogUpdate;
	nextthink = time + 0.1f;
}

void
env_fog_controller::ReceiveEntity(float flSendFlags, float flNew)
{
	if (flSendFlags & ENVFOG_CHANGED_ACTIVE)
		m_iFogActive = readbyte();
	if (flSendFlags & ENVFOG_CHANGED_BLEND)
		m_iFogBlend = readbyte();
	if (flSendFlags & ENVFOG_CHANGED_START)
		m_flFogStart = readfloat();
	if (flSendFlags & ENVFOG_CHANGED_END)
		m_flFogEnd = readfloat();
	if (flSendFlags & ENVFOG_CHANGED_MAXDENSITY)
		m_flFogMaxDensity = readfloat();
	if (flSendFlags & ENVFOG_CHANGED_FARZ)
		m_flFogFarZ = readfloat();
	if (flSendFlags & ENVFOG_CHANGED_COLOR) {
		m_vecFogColor[0] = readfloat();
		m_vecFogColor[1] = readfloat();
		m_vecFogColor[2] = readfloat();
	}
	if (flSendFlags & ENVFOG_CHANGED_COLOR2) {
		m_vecFogColor2[0] = readfloat();
		m_vecFogColor2[1] = readfloat();
		m_vecFogColor2[2] = readfloat();
	}
	if (flSendFlags & ENVFOG_CHANGED_DIR) {
		m_vecFogDir[0] = readfloat();
		m_vecFogDir[1] = readfloat();
		m_vecFogDir[2] = readfloat();
	}
	FogUpdate();

	if (m_iFogBlend) {
		predraw = FogRender;
		drawmask = MASK_ENGINE;
	} else {
		predraw = __NULL__;
		drawmask = 0;
	}
}
#else
float
env_fog_controller::SendEntity(entity ePVEnt, float flSendFlags)
{
	WriteByte(MSG_ENTITY, ENT_FOGCONTROLLER);
	WriteFloat(MSG_ENTITY, flSendFlags);

	if (flSendFlags & ENVFOG_CHANGED_ACTIVE)
		WriteByte(MSG_ENTITY, m_iFogActive);
	if (flSendFlags & ENVFOG_CHANGED_BLEND)
		WriteByte(MSG_ENTITY, m_iFogBlend);
	if (flSendFlags & ENVFOG_CHANGED_START)
		WriteFloat(MSG_ENTITY, m_flFogStart);
	if (flSendFlags & ENVFOG_CHANGED_END)
		WriteFloat(MSG_ENTITY, m_flFogEnd);
	if (flSendFlags & ENVFOG_CHANGED_MAXDENSITY)
		WriteFloat(MSG_ENTITY, m_flFogMaxDensity);
	if (flSendFlags & ENVFOG_CHANGED_FARZ)
		WriteFloat(MSG_ENTITY, m_flFogFarZ);
	if (flSendFlags & ENVFOG_CHANGED_COLOR) {
		WriteFloat(MSG_ENTITY, m_vecFogColor[0]);
		WriteFloat(MSG_ENTITY, m_vecFogColor[1]);
		WriteFloat(MSG_ENTITY, m_vecFogColor[2]);
	}
	if (flSendFlags & ENVFOG_CHANGED_COLOR2) {
		WriteFloat(MSG_ENTITY, m_vecFogColor2[0]);
		WriteFloat(MSG_ENTITY, m_vecFogColor2[1]);
		WriteFloat(MSG_ENTITY, m_vecFogColor2[2]);
	}
	if (flSendFlags & ENVFOG_CHANGED_DIR) {
		WriteFloat(MSG_ENTITY, m_vecFogDir[0]);
		WriteFloat(MSG_ENTITY, m_vecFogDir[1]);
		WriteFloat(MSG_ENTITY, m_vecFogDir[2]);
	}

	return (1);
}

void
env_fog_controller::EvaluateEntity(void)
{
	if (ATTR_CHANGED(m_iFogActive))
		SetSendFlags(ENVFOG_CHANGED_ACTIVE);
	if (ATTR_CHANGED(m_iFogBlend))
		SetSendFlags(ENVFOG_CHANGED_BLEND);
	if (ATTR_CHANGED(m_flFogStart))
		SetSendFlags(ENVFOG_CHANGED_START);
	if (ATTR_CHANGED(m_flFogEnd))
		SetSendFlags(ENVFOG_CHANGED_END);
	if (ATTR_CHANGED(m_flFogMaxDensity))
		SetSendFlags(ENVFOG_CHANGED_MAXDENSITY);
	if (ATTR_CHANGED(m_flFogFarZ))
		SetSendFlags(ENVFOG_CHANGED_FARZ);
	if (ATTR_CHANGED(m_vecFogColor))
		SetSendFlags(ENVFOG_CHANGED_COLOR);
	if (ATTR_CHANGED(m_vecFogColor2))
		SetSendFlags(ENVFOG_CHANGED_COLOR2);
	if (ATTR_CHANGED(m_vecFogDir))
		SetSendFlags(ENVFOG_CHANGED_DIR);

	SAVE_STATE(m_iFogActive);
	SAVE_STATE(m_iFogBlend);
	SAVE_STATE(m_flFogStart);
	SAVE_STATE(m_flFogEnd);
	SAVE_STATE(m_flFogMaxDensity);
	SAVE_STATE(m_flFogFarZ);
	SAVE_STATE(m_vecFogColor);
	SAVE_STATE(m_vecFogColor2);
	SAVE_STATE(m_vecFogDir);
}

void
env_fog_controller::Trigger(entity eAct, int iState)
{
	switch (iState) {
	case TRIG_OFF:
		m_iFogActive = (0);
		break;
	case TRIG_ON:
		m_iFogActive = (1);
		break;
	default:
		m_iFogActive = (1-m_iFogActive);
	}
}

void
env_fog_controller::Respawn(void)
{
	SetSolid(SOLID_NOT);
	SetMovetype(MOVETYPE_PUSH);
	SetModel(GetSpawnModel());
	SetOrigin(GetSpawnOrigin());
	pvsflags = PVSF_IGNOREPVS;

	m_iFogActive = m_iSpawnEnable;
	m_iFogBlend = m_iSpawnBlend;
	m_flFogStart = m_flSpawnStart;
	m_flFogEnd = m_flSpawnEnd;
	m_flFogMaxDensity = m_flSpawnMaxDensity;
	m_flFogFarZ = m_flSpawnFarZ;
	m_vecFogColor = m_vecSpawnColor;
	m_vecFogColor2 = m_vecSpawnColor2;

	if (m_iUseAngles)
		m_vecFogDir = GetSpawnAngles();
	else
		m_vecFogDir = m_vecSpawnDir;
}

void
env_fog_controller::Save(float handle)
{
	super::Save(handle);
	SaveInt(handle, "m_iSpawnEnable", m_iSpawnEnable);
	SaveInt(handle, "m_iSpawnBlend", m_iSpawnBlend);
	SaveFloat(handle, "m_flSpawnStart", m_flSpawnStart);
	SaveFloat(handle, "m_flSpawnEnd", m_flSpawnEnd);
	SaveFloat(handle, "m_flSpawnMaxDensity", m_flSpawnMaxDensity);
	SaveFloat(handle, "m_flSpawnFarZ", m_flSpawnFarZ);
	SaveVector(handle, "m_vecSpawnColor", m_vecSpawnColor);
	SaveVector(handle, "m_vecSpawnColor2", m_vecSpawnColor2);
	SaveVector(handle, "m_vecSpawnDir", m_vecSpawnDir);
	SaveInt(handle, "m_iUseAngles", m_iUseAngles);
	SaveInt(handle, "m_iFogActive", m_iFogActive);
	SaveInt(handle, "m_iFogBlend", m_iFogBlend);
	SaveFloat(handle, "m_flFogStart", m_flFogStart);
	SaveFloat(handle, "m_flFogEnd", m_flFogEnd);
	SaveFloat(handle, "m_flFogMaxDensity", m_flFogMaxDensity);
	SaveFloat(handle, "m_flFogFarZ", m_flFogFarZ);
	SaveVector(handle, "m_vecFogColor", m_vecFogColor);
	SaveVector(handle, "m_vecFogColor2", m_vecFogColor2);
	SaveVector(handle, "m_vecFogDir", m_vecFogDir);
}

void
env_fog_controller::Restore(string strKey, string strValue)
{
	switch (strKey) {
	case "m_iFogActive":
		m_iFogActive = stoi(strValue);
		break;
	case "m_iFogBlend":
		m_iFogBlend = stoi(strValue);
		break;
	case "m_flFogStart":
		m_flFogStart = stof(strValue);
		break;
	case "m_flFogEnd":
		m_flFogEnd = stof(strValue);
		break;
	case "m_flFogMaxDensity":
		m_flFogMaxDensity = stof(strValue);
		break;
	case "m_flFogFarZ":
		m_flFogFarZ = stof(strValue);
		break;
	case "m_vecFogColor":
		m_vecFogColor = stov(strValue);
		break;
	case "m_vecFogColor2":
		m_vecFogColor2 = stov(strValue);
		break;
	case "m_vecFogDir":
		m_vecFogDir = stov(strValue);
		break;
	case "m_iSpawnEnable":
		m_iSpawnEnable = stoi(strValue);
		break;
	case "m_iSpawnBlend":
		m_iSpawnBlend = stoi(strValue);
		break;
	case "m_flSpawnStart":
		m_flSpawnStart = stof(strValue);
		break;
	case "m_flSpawnEnd":
		m_flSpawnEnd = stof(strValue);
		break;
	case "m_flSpawnMaxDensity":
		m_flSpawnMaxDensity = stof(strValue);
		break;
	case "m_flSpawnFarZ":
		m_flSpawnFarZ = stof(strValue);
		break;
	case "m_vecSpawnColor":
		m_vecSpawnColor = stov(strValue);
		break;
	case "m_vecSpawnColor2":
		m_vecSpawnColor2 = stov(strValue);
		break;
	case "m_vecSpawnDir":
		m_vecSpawnDir = stov(strValue);
		break;
	case "m_iUseAngles":
		m_iUseAngles = stoi(strValue);
		break;
	default:
		super::Restore(strKey, strValue);
	}
}

void
env_fog_controller::Input(entity eAct, string strKey, string strValue)
{
	switch (strKey) {
	case "TurnOn":
		m_iFogActive = (0);
		break;
	case "TurnOff":
		m_iFogActive = (1);
		break;
	case "Toggle":
		m_iFogActive = (1-m_iFogActive);
		break;
	case "SetStartDist":
		m_flFogStart = stof(strValue);
		break;
	case "SetEndDist":
		m_flFogEnd = stof(strValue);
		break;
	case "SetMaxDensity":
		m_flFogMaxDensity = stof(strValue);
		break;
	case "SetFarZ":
		m_flFogFarZ = stof(strValue);
		break;
	case "SetColor":
		m_vecFogColor = stov(strValue);
		break;
	case "SetColorSecondary":
		m_vecFogColor2 = stov(strValue);
		break;
	default:
		super::Input(eAct, strKey, strValue);
	}
}

void
env_fog_controller::SpawnKey(string strKey, string strValue)
{
	switch (strKey) {
	case "fogenable":
		m_iSpawnEnable = stoi(strValue);
		break;
	case "fogstart":
		m_flSpawnStart = stof(strValue);
		break;
	case "fogend":
		m_flSpawnEnd = stof(strValue);
		break;
	case "fogblend":
		m_iSpawnBlend = stoi(strValue);
		break;
	case "fogmaxdensity":
		m_flSpawnMaxDensity = stof(strValue);
		break;
	case "farz":
		m_flSpawnFarZ = stof(strValue);
		break;
	case "fogcolor":
		m_vecSpawnColor = stov(strValue) / 255;
		break;
	case "fogcolor2":
		m_vecSpawnColor2 = stov(strValue) / 255;
		break;
	case "fogdir":
		m_vecSpawnDir = stov(strValue);
		break;
	/* because these entities aren't complicated enough */
	case "use_angles":
		m_iUseAngles = stoi(strValue);
		break;
	default:
		super::SpawnKey(strKey, strValue);
	}
}
#endif

void
env_fog_controller::env_fog_controller(void)
{
#ifdef SERVER
	m_vecSpawnColor = [1.0, 1.0, 1.0];
	m_flSpawnMaxDensity = 1.0f;
#endif
}


#ifdef CLIENT
void
env_fog_controller_readentity(float isnew)
{
	env_fog_controller fog = (env_fog_controller)self;
	float flags = readfloat();

	if (isnew)
		spawnfunc_env_fog_controller();

	fog.ReceiveEntity(flags, isnew);
}
#endif