vecLightViewPos question

screenX = cartX + screen_width/2
screenY = screen_height/2 - cartY

// converted it into 
float pos_x = vecLightViewPos[i].x + vecViewPort.x / 2;
float pos_y = vecViewPort.y / 2 - vecLightViewPos[i].y;

float2 normalizedProjectionCoordinatesXY = mul(float4(vecLightPos[i].xyz, 1.0f), matViewProj).xy; // range: -1 <-> 1
// or, with the same price and same result:
// float2 normalizedProjectionCoordinatesXY = mul(float4(vecLightViewPos[i].xyz, 1.0f), matProj).xy;

float2 screenCoordinates = (0.5f + normalizedProjectionCoordinatesXY * 0.5f) * vecViewport.xy; // range: 0 <-> screen_size - 1

float2 normalizedProjectionCoordinatesXY = mul(float4(vecLightViewPos[i].xyz, 1.0f), matProj).xy;
float normalizedProjectionCoordinatesOfOuterPointOfLightSphereX = mul(float4(vecLightViewPos[i].xy, vecLightViewPos[i].z - vecLightViewPos[i].w, 1.0f), matProj).x ; // doing the same in world space would need far more computations
float projectedLightRadiusInScreenPixels = vecViewPort.x * (normalizedProjectionCoordinatesOfOuterPointOfLightSphereX - normalizedProjectionCoordinatesXY.x) / 2.0f;

float2 normalizedProjectionCoordinatesXY = mul(float4(vecLightViewPos[i].xyz, 1.0f), matProj).xy;
float normalizedProjectionCoordinatesOfOuterPointOfLightSphereX = mul(float4(vecLightViewPos[i].xy, vecLightViewPos[i].z - vecLightViewPos[i].w, 1.0f), matProj).x;
float projectedLightRadiusInScreenPixels = vecViewPort.x * (normalizedProjectionCoordinatesOfOuterPointOfLightSphereX - normalizedProjectionCoordinatesXY.x) / 2.0f;
float2 screenCoordinates = (0.5f + normalizedProjectionCoordinatesXY * 0.5f) * vecViewPort.xy;

float4 clipSpaceCoordinates = mul(float4(vecLightPos[i].xyz, 1.0f), matViewProj);
float2 normalizedProjectionCoordinatesXY = clipSpaceCoordinates.xy / clipSpaceCoordinates.w;
float2 normalizedScreenCoordinates;
normalizedScreenCoordinates.x = (1.0f + normalizedProjectionCoordinatesXY.x) / 4.0f;
normalizedScreenCoordinates.y = (1.0f - normalizedProjectionCoordinatesXY.y) / 4.0f;
float2 screenCoordinates = normalizedScreenCoordinates * vecViewPort.xy;

#include <acknex.h>
#include <default.c>

MATERIAL *mtlNormalizedScreenCoords =
{
	effect = "
		float4x4 matWorldViewProj;
	
		void VS (
			in  float4 inPos     : POSITION,
			out float4 outPos    : POSITION,
			out float4 outColor0 : COLOR0)
		{
			outPos = mul(inPos, matWorldViewProj);
			outColor0.r = (1.0f + outPos.x / outPos.w) / 4.0f;
			outColor0.g = (1.0f - outPos.y / outPos.w) / 4.0f;
			outColor0.b = 0.0;
			outColor0.a = 1.0;
		}
	
		technique
		{
			pass
			{
				VertexShader = compile vs_2_0 VS();
			}
		}
	";
}

void main()
{
	wait(1);
	level_load(SPHERE_MDL);
	camera->material = mtlNormalizedScreenCoords;
	camera->x = -30;
	
	while(!key_esc)
	{
		if(proc_status(def_move) == 0)
		{
			camera->pan = clamp(camera->pan + mickey.x * 0.2, -30, 30);
			camera->tilt = clamp(camera->tilt + mickey.y * 0.2, -20, 20);
		}
		wait(1);
	}
	
	sys_exit(NULL);
}

float3 clipSpaceCoordinates = mul(float4(vecLightPos[i].xyz, 1.0f), matViewProj).xy;
float2 normalizedProjectionCoordinatesXY = clipSpaceCoordinates.xy / clipSpaceCoordinates.w;

normalizedScreenCoordinates.y = (1.0f - normalizedProjectionCoordinatesXY.y) / 4.0f;

normalizedProjectionCoordinatesXY.x

float4 clipSpaceCoordinates = mul(float4(vecLightViewPos[i].xyz, 1.0f), matViewProj);
float2 normalizedProjectionCoordinatesXY = clipSpaceCoordinates.xy / clipSpaceCoordinates.w;
float2 normalizedScreenCoordinates;
normalizedScreenCoordinates.x = (1.0f + normalizedProjectionCoordinatesXY.x) / 4.0f;
normalizedScreenCoordinates.y = (1.0f - normalizedProjectionCoordinatesXY.y) / 4.0f;
float2 screenCoordinates = normalizedScreenCoordinates * vecViewPort.xy;

float normalizedProjectionCoordinatesOfOuterPointOfLightSphereX = mul(float4(vecLightViewPos[i].xy, vecLightViewPos[i].z - vecLightViewPos[i].w, 1.0f), matProj).x;
float projectedLightRadiusInScreenPixels = vecViewPort.x * (normalizedProjectionCoordinatesOfOuterPointOfLightSphereX - normalizedProjectionCoordinatesXY.x) / 2.0f;

vec4 clipSpacePos = projectionMatrix * (viewMatrix * vec4(point3D, 1.0));
vec3 ndcSpacePos = clipSpacePos.xyz / clipSpacePos.w;
vec2 windowSpacePos = ((ndcSpacePos.xy + 1.0) / 2.0) * viewSize + viewOffset; // OpenGL bottom-left of the window
vec2 windowSpacePos = vec2(((ndcSpacePos.x + 1.0) / 2.0) * viewSize.x + viewOffset.x, ((1.0 - ndcSpacePos.y) / 2.0) * viewSize.y + viewOffset.y); // top-left

float4 clipSpacePos = mul(float4(vecLightPos[i].xyz, 1.0f), matViewProj);
float3 ndcSpacePos = clipSpacePos.xyz / clipSpacePos.w;
float2 windowSpacePos = float2(((ndcSpacePos.x + 1.0) / 2.0) * vecViewPort.x, ((1.0 - ndcSpacePos.y) / 2.0) * vecViewPort.y);

float2 normalizedProjectionCoordinatesXY = mul(float4(vecLightViewPos[i].xyz, 1.0f), matProj).xy;
float normalizedProjectionCoordinatesOfOuterPointOfLightSphereX = mul(float4(vecLightViewPos[i].xy, vecLightViewPos[i].z - vecLightViewPos[i].w, 1.0f), matProj).x ; // doing the same in world space would need far more computations
float projectedLightRadiusInScreenPixels = vecViewPort.x * (normalizedProjectionCoordinatesOfOuterPointOfLightSphereX - normalizedProjectionCoordinatesXY.x) / 2.0f;

#include <acknex.h>
#include <default.c>

MATERIAL *mtlProjectedLights =
{
	effect = "
		float4x4 matProj;
		const float4 vecViewPort;
		
		float iLights;
		float4 vecLightPos[8];
		float4 vecLightViewPos[8];
		float4 vecLightDir[8];
		float4 vecLightColor[8];
		
		texture TargetMap;
		
		sampler postTex = sampler_state
		{
			Texture = <TargetMap>;
			MinFilter = Point; // No need of linear interpolation on pixel to pixel pp effects. 
		};
		
		float4 PS (
			in float2 inTex : TEXCOORD0, 
			in float2 inPos : VPOS) : COLOR0
		{
			float4 color0 = float4(0, 0, 0, 1.0f);
			
			for(float i = 0; i < iLights; i += 1.0f)
			{
				if(vecLightDir[i].w > 0) // Avoid spotlights
					continue;
				
				float4 clipSpacePos = mul(float4(vecLightViewPos[i].xyz, 1.0f), matProj);
				float2 ndcSpacePos = clipSpacePos.xy / clipSpacePos.w;
				float2 windowSpacePos = float2(1.0f + ndcSpacePos.x, 1.0f - ndcSpacePos.y) * vecViewPort.xy * 0.5f;
				
				float4 clipSpaceOutterPoint = mul(float4(vecLightViewPos[i].x - vecLightPos[i].w, vecLightViewPos[i].yz, 1.0f), matProj);
				float ndcSpaceOutterPoint = clipSpaceOutterPoint.x / clipSpaceOutterPoint.w;
				
				float windowSpaceRadius = (ndcSpacePos.x - ndcSpaceOutterPoint) * vecViewPort.x * 0.5f;
				color0.rgb += vecLightColor[i].rgb * saturate((1.0f - length(inPos - windowSpacePos) / windowSpaceRadius));
			}
			
			float3 albedo = tex2D(postTex, inTex).rgb;
			color0.rgb = albedo * saturate(color0.rgb);
			
			return color0;
		}
		
		technique
		{
			pass one
			{
				ZWriteEnable = False;
				AlphaBlendEnable = False;
				PixelShader = compile ps_3_0 PS();
			}
		}	
	";
}

VIEW *camProjectedLights =
{
	material = mtlProjectedLights;
	flags = PROCESS_TARGET | CHILD | SHOW;
}

void main () {
	video_mode = 10;
	sun_light = 0;
	wait(3);
	level_load("level.wmb");
	camera->arc = 100;
	camera->stage = camProjectedLights;
	
	while(!key_esc)
		wait(1);
	
	sys_exit(NULL);
}

#define light_blue skill1
#define light_green skill2
#define light_red skill3
#define light_range skill4
//uses: light_blue, light_green, light_red, light_range
action actLight () {
	my->blue = my->light_blue;
	my->green = my->light_green;
	my->red = my->light_red;
	my->lightrange = my->light_range;
	
	vec_set(&my->skill20, &my->x);
	my->skill23 = random(360);
	
	my->flags |= UNLIT | LIGHT | BRIGHT;
	
	while(1)
	{
		my->lightrange = my->light_range + random(10); // flicker
		my->x = my->skill20 + fsin(my->skill23 + total_ticks * 4, 80);
		my->y = my->skill21 + fcos(my->skill23 + total_ticks * 4, 80);
		wait(1);
	}
}

RGB = 1 - CMY;
CMY = 1 - RGB;