internal static ISettings GetSettings(IConfiguration configuration)
{
string sourceRoot = configuration.GetValue <string>("SourceRoot");
string destinationRootUrl = configuration.GetValue <string>("DestinationRootUrl");
string destinationRootPath = configuration.GetValue <string>("DestinationRootPath");
ILocation destinationRoot = new Location(new Uri(destinationRootUrl), destinationRootPath);
IConfigurationSection rateLimiterConfig = configuration.GetSection("RateLimiter");
IRateLimiterSettings rateLimiterSettings = new RateLimiterSettings
{
Enabled = rateLimiterConfig.GetValue("Enabled", false),
TimeWindowInMinutes = rateLimiterConfig.GetValue("TimeWindowInMinutes", 10),
MaxRequestsInTimeWindow = rateLimiterConfig.GetValue("MaxRequestsInTimeWindow", 100),
MaxBytesInTimeWindow = rateLimiterConfig.GetValue("MaxBytesInTimeWindow", 1024 * 1024 * 50),
Whitelist = rateLimiterConfig.GetSection("Whitelist").GetChildren().ToList().Select(x => x.Value).ToArray(),
Blacklist = rateLimiterConfig.GetSection("Blacklist").GetChildren().ToList().Select(x => x.Value).ToArray()
};
IConfigurationSection loggerConfig = configuration.GetSection("Logger");
ILoggerSettings loggerSettings = new LoggerSettings
{
WriteInfo = loggerConfig.GetValue("WriteInfo", false),
WriteWarnings = loggerConfig.GetValue("WriteWarnings", false),
WriteErrors = loggerConfig.GetValue("WriteErrors", false),
ToConsole = loggerConfig.GetValue("ToConsole", false),
ToFile = loggerConfig.GetValue("ToFile", false),
Directory = loggerConfig.GetValue("Directory", string.Empty)
};
IConfigurationSection gifConfig = configuration.GetSection("GifSettings");
IGifSettings gifSettings = new GifSettings
{
PostProcessorEnabled = gifConfig.GetValue("PostProcessorEnabled", false),
PostProcessorCommand = gifConfig.GetValue("PostProcessorCommand", string.Empty)
};
IConfigurationSection jpegConfig = configuration.GetSection("JpegSettings");
IJpegSettings jpegSettings = new JpegSettings
{
Quality = jpegConfig.GetValue("Quality", 75),
PostProcessorEnabled = jpegConfig.GetValue("PostProcessorEnabled", false),
PostProcessorCommand = jpegConfig.GetValue("PostProcessorCommand", string.Empty)
};
IConfigurationSection pngConfig = configuration.GetSection("PngSettings");
IPngSettings pngSettings = new PngSettings
{
CompressionLevel = pngConfig.GetValue("CompressionLevel", 6),
PostProcessorEnabled = pngConfig.GetValue("PostProcessorEnabled", false),
PostProcessorCommand = pngConfig.GetValue("PostProcessorCommand", string.Empty)
};
Settings settings = new Settings(sourceRoot, destinationRoot, rateLimiterSettings, loggerSettings, gifSettings, jpegSettings, pngSettings);
return(settings);
}
//the meat of the rendering is in here
void LateUpdate()
{
float adjustedSize = GetAdjustedSize();
//restore cameras to original state
Cam.enabled = false;
Cam.aspect = Config.screenW / Config.screenH;
Cam.transform.position = transform.position + transform.forward * -adjustedSize;
Cam.transform.localRotation = Quaternion.identity;
Cam.nearClipPlane = adjustedSize - nearClip * size;
Cam.farClipPlane = adjustedSize + farClip * size;
Cam.fieldOfView = fov;
Cam.orthographicSize = size * 0.5f;
camFinal.enabled = true;
camFinal.orthographicSize = 0.001f;
//view cone for 3d screenshot
float savedViewCone = Config.viewCone.Value;
if (screenshot3DQueued)
{
Config.viewCone.Value = Config.viewCone.defaultValue;
}
//****************************
//if not rendering views
//****************************
if (fullyDisabled || (!renderInEditor && !Application.isPlaying))
{
Cam.targetTexture = null;
camFinal.enabled = false;
Cam.enabled = true;
HandleOffset(0, Config.verticalAngle);
return;
}
//****************************
//rendering views
//****************************
matFinal.mainTexture = rtFinal;
camFinal.clearFlags = CameraClearFlags.SolidColor;
Cam.clearFlags = CameraClearFlags.SolidColor;
// if it's a test, cover the rtFinal in colortest first
Graphics.SetRenderTarget(rtFinal);
if ((int)Config.test == 1)
{
GL.PushMatrix();
GL.LoadPixelMatrix(0, rtFinal.width, rtFinal.height, 0);
Graphics.DrawTexture(new Rect(0, 0, rtFinal.width, rtFinal.height), colorTestTex);
GL.PopMatrix();
Cam.backgroundColor = Color.clear;
}
else
{
GL.Clear(false, true, Color.black);
Cam.backgroundColor = Color.black;
}
Graphics.SetRenderTarget(rtMain);
//handle loop
for (int i = 0; i < Config.numViews; i++)
{
//reset render texture
Cam.targetTexture = rtMain;
//offset or rotation
HandleOffset(GetAngleAtView(i), Config.verticalAngle);
//broadcast the onViewRender action
if (onViewRender != null && Application.isPlaying)
{
onViewRender(i);
}
//actually render~!
Cam.Render();
//copy to fullsize rt
int ri = (tilesX * tilesY) - i - 1;
int x = (i % tilesX) * rtMain.width;
int y = (ri / tilesX) * rtMain.height;
Rect rtRect = new Rect(x, y, rtMain.width, rtMain.height);
if (rtMain.IsCreated() && rtFinal.IsCreated())
{
Graphics.SetRenderTarget(rtFinal);
GL.PushMatrix();
GL.LoadPixelMatrix(0, rtFinal.width, rtFinal.height, 0);
Graphics.DrawTexture(rtRect, rtMain);
GL.PopMatrix();
}
}
//sending variables to the shader
//pitch
float screenInches = (float)Config.screenW / Config.DPI;
float newPitch = Config.pitch * screenInches;
//account for tilt in measuring pitch horizontally
newPitch *= Mathf.Cos(Mathf.Atan(1f / Config.slope));
matFinal.SetFloat("pitch", newPitch);
//tilt
float newTilt = Config.screenH / (Config.screenW * Config.slope);
matFinal.SetFloat("tilt", lentilPrintQueued ? 0 : newTilt);
//center
matFinal.SetFloat("center", Config.center);
//numViews
//during color test, force views down to 2
float newNumViews = (int)Config.numViews;
matFinal.SetFloat("numViews", newNumViews);
//tiles
matFinal.SetFloat("tilesX", tilesX);
matFinal.SetFloat("tilesY", tilesY);
//flip x
matFinal.SetFloat("flipX", Config.flipImage);
//flip y
matFinal.SetFloat("flipY", Config.flipImageY);
//flip subp
matFinal.SetFloat("flipSubp", Config.flipSubp);
//lentil disabling of subpixels
matFinal.SetInt("subs", lentilPrintQueued ? 1 : 3);
//broadcast the onViewRender action one last time,
//incase there is a need to change things before the final render
if (onViewRender != null && Application.isPlaying)
{
onViewRender((int)Config.numViews);
}
//if a screenshot is queued, put it here
if (screenshot3DQueued)
{
screenshot3DQueued = false;
string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
string filename = Application.productName + "-3D-Scr-";
int filenumber = 0;
string finalPath = "";
do
{
finalPath = Path.Combine(path, filename + filenumber++ + ".png");
}while (File.Exists(finalPath));
//write a png
Texture2D mainTexture = new Texture2D(rtFinal.width, rtFinal.height);
RenderTexture.active = rtFinal;
mainTexture.ReadPixels(new Rect(0, 0, rtFinal.width, rtFinal.height), 0, 0, false);
var texBytes = mainTexture.EncodeToPNG();
File.WriteAllBytes(finalPath, texBytes);
print("saved " + Path.GetFileName(finalPath) + " to desktop");
//set the view cone back
Config.viewCone.Value = savedViewCone;
}
//wiggle gif
if (wiggleGifQueued)
{
wiggleGifQueued = false;
//if there is no streamingassetspath in the build, create one
if (!Directory.Exists(Application.streamingAssetsPath))
{
Directory.CreateDirectory(Application.streamingAssetsPath);
}
//read wigglegif settings if they're there
string gifPath = Path.Combine(Application.streamingAssetsPath, "gifSettings.json");
GifSettings gifSettings = new GifSettings();
if (!File.Exists(gifPath))
{
string gifSettingsJsonStr = JsonUtility.ToJson(gifSettings, true);
File.WriteAllText(gifPath, gifSettingsJsonStr);
}
else
{
string gifSettingsJsonStr = File.ReadAllText(gifPath);
gifSettings = JsonUtility.FromJson <GifSettings>(gifSettingsJsonStr);
}
string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
string filename = Application.productName + "-";
int filenumber = 0;
string finalPath = "";
do
{
finalPath = Path.Combine(path, filename + filenumber++ + ".gif");
}while (File.Exists(finalPath));
var gifEncoder = new uGIF.GIFEncoder();
var ms = new MemoryStream();
gifEncoder.useGlobalColorTable = true;
gifEncoder.repeat = 0;
gifEncoder.Start(ms);
Texture2D gifTex = new Texture2D(rtMain.width, rtMain.height);
int numViews = (int)HoloPlay.Config.numViews;
int cutoff = 14;
for (int i = 0; i < numViews * 2; i++)
{
int r = i;
if (i >= numViews)
{
r = numViews * 2 - i - 1;
}
if (r < cutoff || numViews - r - 1 < cutoff)
{
continue;
}
float newR = Mathf.InverseLerp(cutoff, numViews - cutoff - 1, r);
float fpsMod = Mathf.Sin(newR * Mathf.PI) * 0.5f + 0.5f;
gifEncoder.FPS = 30f * fpsMod;
int x = (r % tilesX) * rtMain.width;
int y = (r / tilesX) * rtMain.height;
RenderTexture.active = rtFinal;
gifTex.ReadPixels(new Rect(x, y, rtMain.width, rtMain.height), 0, 0, false);
var gifImage = new uGIF.Image(gifTex);
gifImage.Flip();
gifImage.ResizeBilinear((int)(rtMain.height * Config.screenW / Config.screenH), rtMain.height);
gifEncoder.AddFrame(gifImage);
}
gifEncoder.Finish();
var gifBytes = ms.GetBuffer();
File.WriteAllBytes(finalPath, gifBytes);
print("saved " + Path.GetFileName(finalPath) + " to desktop");
}
}
public GifItem(GifSettings Settings)
{
_settings = Settings;
}
public void TestFullConfiguration()
{
string sourceRoot = "source/root";
Location destinationRoot = new Location(new Uri("http://site.com/images"), "/var/www/site.com/images");
RateLimiterSettings rateLimiterSettings = new RateLimiterSettings();
rateLimiterSettings.Enabled = true;
rateLimiterSettings.TimeWindowInMinutes = 42;
rateLimiterSettings.MaxRequestsInTimeWindow = 1337;
rateLimiterSettings.MaxBytesInTimeWindow = 1000000;
rateLimiterSettings.Whitelist = new string[] { "1.3.3.7" };
rateLimiterSettings.Blacklist = new string[] { "6.6.6.666", "666.666.666.666" };
LoggerSettings loggerSettings = new LoggerSettings();
loggerSettings.WriteInfo = true;
loggerSettings.WriteWarnings = true;
loggerSettings.WriteErrors = true;
loggerSettings.ToConsole = true;
loggerSettings.ToFile = true;
loggerSettings.Directory = "path/to/log";
GifSettings gifSettings = new GifSettings();
gifSettings.PostProcessorEnabled = true;
gifSettings.PostProcessorCommand = "path/to/gifsicle some gifsicle args";
JpegSettings jpegSettings = new JpegSettings();
jpegSettings.Quality = 50;
jpegSettings.PostProcessorEnabled = true;
jpegSettings.PostProcessorCommand = "path/to/jpegtran some jpegtran args";
PngSettings pngSettings = new PngSettings();
pngSettings.CompressionLevel = 3;
pngSettings.PostProcessorEnabled = true;
pngSettings.PostProcessorCommand = "path/to/optipng some optipng args";
Settings settings = new Settings(sourceRoot, destinationRoot, rateLimiterSettings, loggerSettings, gifSettings, jpegSettings, pngSettings);
Assert.True(settings.SourceRoot == sourceRoot);
Assert.True(settings.DestinationRoot.AbsoluteUrl == destinationRoot.AbsoluteUrl);
Assert.True(settings.DestinationRoot.AbsolutePath == destinationRoot.AbsolutePath);
Assert.True(settings.RateLimiterSettings.Enabled == true);
Assert.True(settings.RateLimiterSettings.TimeWindowInMinutes == 42);
Assert.True(settings.RateLimiterSettings.MaxRequestsInTimeWindow == 1337);
Assert.True(settings.RateLimiterSettings.MaxBytesInTimeWindow == 1000000);
Assert.True(settings.RateLimiterSettings.Whitelist.Length == 1 && settings.RateLimiterSettings.Whitelist[0] == "1.3.3.7");
Assert.True(settings.RateLimiterSettings.Blacklist.Length == 2 && settings.RateLimiterSettings.Blacklist[0] == "6.6.6.666" && settings.RateLimiterSettings.Blacklist[1] == "666.666.666.666");
Assert.True(settings.LoggerSettings.WriteInfo == true);
Assert.True(settings.LoggerSettings.WriteWarnings == true);
Assert.True(settings.LoggerSettings.WriteErrors == true);
Assert.True(settings.LoggerSettings.ToConsole == true);
Assert.True(settings.LoggerSettings.ToFile == true);
Assert.True(settings.LoggerSettings.Directory == "path/to/log");
Assert.True(settings.GifSettings.PostProcessorEnabled);
Assert.True(settings.GifSettings.PostProcessorCommand == "path/to/gifsicle some gifsicle args");
Assert.True(settings.JpegSettings.Quality == 50);
Assert.True(settings.JpegSettings.PostProcessorEnabled);
Assert.True(settings.JpegSettings.PostProcessorCommand == "path/to/jpegtran some jpegtran args");
Assert.True(settings.PngSettings.CompressionLevel == 3);
Assert.True(settings.PngSettings.PostProcessorEnabled);
Assert.True(settings.PngSettings.PostProcessorCommand == "path/to/optipng some optipng args");
}
