// CalcFov.c - example code to calculate correct FOV for widescreen
// resolution
//
// quakeworld.nu - oldman

#include <stdio.h>
#include <math.h>
#include <stdlib.h>

static float CalcFov (float fov_x, float width, float height) {
float x;

x = width / tan(fov_x / 360 * M_PI);
return atan (height / x) * 360 / M_PI;
}

int main(int argc, char** argv)
{
int width = 1280;
/* int width = 960; */
int height = 720;

float fov_x, fov_y;
int scr_fov = 110;

float screenaspect = (float) width / (float) height;

if (screenaspect > 1.34)
{
// widescreen - width is based on a target height
// correct y fov for the full height view
fov_y = CalcFov (scr_fov, height * (320.0f / 240.0f), height);
fov_x = CalcFov (fov_y, height, width);
printf("fov_x=%.8f fov_y=%.8f\n", fov_x, fov_y);
}
else
{
// tallscreen or default fov where height is based on a target width
// correct x fov for the full width view
fov_x = scr_fov;
fov_y = CalcFov (scr_fov, width, height);
printf("fov_x=%.8f fov_y=%.8f\n", fov_x, fov_y);
}

return 0;
}

if (screenaspect > 1.34)
{
r_refdef.fov_y = scr_fov.value * 0.81933107777777777777777777777778;// = 73.739797 / 90
r_refdef.fov_x = CalcFov (r_refdef.fov_y, r_refdef.vrect.height, r_refdef.vrect.width);
}
else
{
r_refdef.fov_x = scr_fov.value;
r_refdef.fov_y = CalcFov (r_refdef.fov_x, r_refdef.vrect.width, r_refdef.vrect.height);
}

qboolean OnChange_vid_conwidth (cvar_t *var, char *string)
{
vid.width = bound(320, (atoi(string)), vid_width.value);
vid.width &= 0xfff8; // make it a multiple of eight

Cvar_SetValue("vid_conwidth", vid.width);

vid.aspect = ((float)vid_height.value / (float)vid_width.value) * (320.0 / 240.0);

//pick a conheight that matches the correct aspect
if (vid.aspect < 1)
vid.height = (vid.width * 0.625);
else
vid.height = (vid.width * 0.750);

Cvar_SetValue("vid_conheight", vid.height);

conback->width = vid.conwidth = vid.width;
conback->height = vid.conheight = vid.height;

vid.recalc_refdef = 1;

return true;
}
cvar_t vid_conwidth = {"vid_conwidth", "640", true, false, OnChange_vid_conwidth};

#!/usr/bin/ruby

require 'mathn'
require 'fract.rb'

def calculate(resolution)
#Split the 1280x1024 res into an array with each num as an element
res = resolution.to_s.split('x')
#Make the aspect ratio
ratio = (res[0].to_f/res[1].to_f).to_fraction

#Find the least common multiple, so we can get equal height aspects.
lcm = ratio[1].lcm 3

#Gets put in as W2 and W1 in formula below.
new_scr_w = lcm / ratio[1]*ratio[0]
old_scr_w = lcm / 4 * 3

#Our formula uses degrees, Ruby uses radians.
to_rad = Math:I / 180
to_deg = 180 / Math:I

#The games current fov. Needs to be in radian form.
cur_fov = 90.0 * to_rad

#Actually calculate it.
#FOV2 = 2 x Inverse Tangent [(W2/W1) x Tangent (FOV1/2)]
#Where W2 and W1 are the two screen widths for equal screen height. FOV1 is the games original FOV.
#Must convert end answer to degrees, as most programming languages use Radians.
answer_raw = (2 * (Math.atan((new_scr_w/old_scr_w) * Math.tan(cur_fov/2))) * to_deg)

#This will round our answer to the third digit.
answer = (((answer_raw*1000).round)/1000).to_f

return answer
end

puts calculate(ARGV)

class Float
def number_decimal_places
self.to_s.length-2
end

def to_fraction
higher = 10**self.number_decimal_places
lower = self*higher

gcden = greatest_common_divisor(higher, lower)

return (lower/gcden).round, (higher/gcden).round
end

private
def greatest_common_divisor(a, b)
while a%b != 0
a,b = b.round,(a%b).round
end
return b
end
end