#include "internal.h"

void C3Di_LightMtlBlend(C3D_Light* light)
{
	int i;
	C3D_Material* mtl = &light->parent->material;
	C3D_LightMatConf* conf = &light->conf.material;
	memset(conf, 0, sizeof(*conf));

	for (i = 0; i < 3; i ++)
	{
		conf->specular0 |= ((u32)(255*(mtl->specular0[i]*light->specular0[i]))) << (i*10);
		conf->specular1 |= ((u32)(255*(mtl->specular1[i]*light->specular1[i]))) << (i*10);
		conf->diffuse   |= ((u32)(255*(mtl->diffuse[i]  *light->diffuse[i])))   << (i*10);
		conf->ambient   |= ((u32)(255*(mtl->ambient[i]  *light->ambient[i])))   << (i*10);
	}
}

int C3D_LightInit(C3D_Light* light, C3D_LightEnv* env)
{
	int i;
	memset(light, 0, sizeof(*light));

	for (i = 0; i < 8; i ++)
		if (!env->lights[i])
			break;
	if (i == 8) return -1;

	env->lights[i] = light;
	light->flags = C3DF_Light_Enabled | C3DF_Light_Dirty | C3DF_Light_MatDirty;
	light->id = i;
	light->parent = env;
	light->diffuse[0]   = light->diffuse[1]   = light->diffuse[2]   = 1.0f;
	light->specular0[0] = light->specular0[1] = light->specular0[2] = 1.0f;
	light->specular1[0] = light->specular1[1] = light->specular1[2] = 1.0f;

	env->flags |= C3DF_LightEnv_LCDirty;
	return i;
}

void C3D_LightEnable(C3D_Light* light, bool enable)
{
	if ((light->flags & C3DF_Light_Enabled) == (enable?C3DF_Light_Enabled:0))
		return;

	if (enable)
		light->flags |= C3DF_Light_Enabled;
	else
		light->flags &= ~C3DF_Light_Enabled;

	light->parent->flags |= C3DF_LightEnv_LCDirty;
}

void C3D_LightTwoSideDiffuse(C3D_Light* light, bool enable)
{
	if (enable)
		light->conf.config |= BIT(1);
	else
		light->conf.config &= ~BIT(1);
	light->flags |= C3DF_Light_Dirty;
}

void C3D_LightGeoFactor(C3D_Light* light, int id, bool enable)
{
	id = 2 + (id&1);
	if (enable)
		light->conf.config |= BIT(id);
	else
		light->conf.config &= ~BIT(id);
	light->flags |= C3DF_Light_Dirty;
}

void C3D_LightAmbient(C3D_Light* light, float r, float g, float b)
{
	light->ambient[0] = b;
	light->ambient[1] = g;
	light->ambient[2] = r;
	light->flags |= C3DF_Light_MatDirty;
}

void C3D_LightDiffuse(C3D_Light* light, float r, float g, float b)
{
	light->diffuse[0] = b;
	light->diffuse[1] = g;
	light->diffuse[2] = r;
	light->flags |= C3DF_Light_MatDirty;
}

void C3D_LightSpecular0(C3D_Light* light, float r, float g, float b)
{
	light->specular0[0] = b;
	light->specular0[1] = g;
	light->specular0[2] = r;
	light->flags |= C3DF_Light_MatDirty;
}

void C3D_LightSpecular1(C3D_Light* light, float r, float g, float b)
{
	light->specular1[0] = b;
	light->specular1[1] = g;
	light->specular1[2] = r;
	light->flags |= C3DF_Light_MatDirty;
}

void C3D_LightPosition(C3D_Light* light, C3D_FVec* pos)
{
	// Enable/disable positional light depending on W coordinate
	light->conf.config &= ~BIT(0);
	light->conf.config |= (pos->w == 0.0f);
	light->conf.position[0] = f32tof16(pos->x);
	light->conf.position[1] = f32tof16(pos->y);
	light->conf.position[2] = f32tof16(pos->z);
	light->flags |= C3DF_Light_Dirty;
}

static void C3Di_EnableCommon(C3D_Light* light, bool enable, u32 bit)
{
	C3D_LightEnv* env = light->parent;
	u32* var = &env->conf.config[1];

	if (enable == !(*var & bit))
		return;

	if (!enable)
		*var |= bit;
	else
		*var &= ~bit;

	env->flags |= C3DF_LightEnv_Dirty;
}

void C3D_LightShadowEnable(C3D_Light* light, bool enable)
{
	C3Di_EnableCommon(light, enable, GPU_LC1_SHADOWBIT(light->id));
}

void C3D_LightSpotEnable(C3D_Light* light, bool enable)
{
	C3Di_EnableCommon(light, enable, GPU_LC1_SPOTBIT(light->id));
}

static inline u16 floattofix2_11(float x)
{
	return (u16)((s32)(x * (1U<<11)) & 0x1FFF);
}

void C3D_LightSpotDir(C3D_Light* light, float x, float y, float z)
{
	C3Di_EnableCommon(light, true, GPU_LC1_SPOTBIT(light->id));
	C3D_FVec vec = FVec3_New(-x, -y, -z);
	vec = FVec3_Normalize(vec);
	light->conf.spotDir[0] = floattofix2_11(vec.x);
	light->conf.spotDir[1] = floattofix2_11(vec.y);
	light->conf.spotDir[2] = floattofix2_11(vec.z);
	light->flags |= C3DF_Light_Dirty;
}

void C3D_LightSpotLut(C3D_Light* light, C3D_LightLut* lut)
{
	bool hasLut = lut != NULL;
	C3Di_EnableCommon(light, hasLut, GPU_LC1_SPOTBIT(light->id));
	light->lut_SP = lut;
	if (hasLut)
		light->flags |= C3DF_Light_SPDirty;
}

void C3D_LightDistAttnEnable(C3D_Light* light, bool enable)
{
	C3Di_EnableCommon(light, enable, GPU_LC1_ATTNBIT(light->id));
}

void C3D_LightDistAttn(C3D_Light* light, C3D_LightLutDA* lut)
{
	bool hasLut = lut != NULL;
	C3Di_EnableCommon(light, hasLut, GPU_LC1_ATTNBIT(light->id));
	if (!hasLut) return;

	light->conf.distAttnBias  = f32tof20(lut->bias);
	light->conf.distAttnScale = f32tof20(lut->scale);
	light->lut_DA = &lut->lut;
	light->flags |= C3DF_Light_Dirty | C3DF_Light_DADirty;
}