public PlayerAvatarElement(float x, float y, string playerUsername, int avatarIndex, LabelStyle labelStyle, Action onClick = null, float spriteSize = 128f)
: base(Mathf.Ceiling(spriteSize), Mathf.Ceiling(spriteSize) * 2)
{
bounds = new Rectangle(x, y, spriteSize, spriteSize * 2f);
this.playerUsername = playerUsername;
this.onClick += onClick;
this.labelStyle = labelStyle;
var playerAvatarPath = "data/sprites/avatars/";
if (avatarIndex < 5)
{
playerAvatarPath += $"female_{avatarIndex + 1}_";
}
else
{
playerAvatarPath += $"male_{avatarIndex - 4}_";
}
if (Math.Abs(spriteSize - 128f) < 0.00001f)
{
playerAvatarPath += "128.png";
}
else
{
playerAvatarPath += "64.png";
}
playerAvatar = new game.Sprite(playerAvatarPath, true, false);
SetXY(x, y);
Draw();
}
string WrappedText(out int numOfLines)
{
float w = _easy.TextWidth(_text);
numOfLines = Mathf.Ceiling(w / (_easy.width - 2 * _paddingX));
string[] words = _text.Split(' ');
List <string> lines = new List <string>();
string line = "";
for (int i = 0; i < words.Length; i++)
{
string tempLine = line + words[i];
w = _easy.TextWidth(tempLine);
if (w > (_easy.width - 2 * _paddingX))
{
lines.Add(line.Trim());
line = words[i] + " ";
}
else
{
line += words[i] + " ";
}
}
if (!string.IsNullOrWhiteSpace(line))
{
lines.Add(line);
}
return(string.Join(Environment.NewLine, lines));
}
// Starts a transfer of raw data from the host to a device buffer
public unsafe static void PushBuffer(byte *src, uint length, Vk.Buffer dst, uint dstOffset)
{
// Calculate transfer information
uint blockCount = (uint)Mathf.Ceiling(length / (float)DEFAULT_BUFFER_SIZE);
// Iterate over the transfer blocks
for (uint bidx = 0; bidx < blockCount; ++bidx)
{
// Calculate offsets and block sizes
uint blockOff = bidx * DEFAULT_BUFFER_SIZE;
byte *currSrc = src + blockOff;
uint currDstOffset = dstOffset + blockOff;
uint currLength = Math.Min(length - blockOff, DEFAULT_BUFFER_SIZE);
// Wait on the previous transfer
s_pushFence.Wait();
s_pushFence.Reset();
// Map the staging buffer, and copy the memory
IntPtr mapped = s_pushMemory.Map(0, currLength);
System.Buffer.MemoryCopy(currSrc, mapped.ToPointer(), currLength, currLength);
s_pushMemory.Unmap();
// Start recording
s_pushCommands.Begin(ONE_TIME_SUBMIT_INFO);
// Add the transfer command
Vk.BufferCopy bc = new Vk.BufferCopy(currLength, 0, currDstOffset);
s_pushCommands.CmdCopyBuffer(s_pushBuffer, dst, bc);
// End recording, and submit
s_pushCommands.End();
s_queue.Submit(s_pushSubmitInfo, fence: s_pushFence);
}
}
public Label(float x, float y, float width, float height, string labelText, LabelStyle labelStyle)
: base(Mathf.Ceiling(width), Mathf.Ceiling(height), false)
{
bounds = new Rectangle(x, y, width, height);
LabelText = labelText;
this.labelStyle = labelStyle;
Draw();
SetXY(x, y);
}
public RectangleElement(float x, float y, float width, float height, Color fillColor, Color strokeColor, float strokeWeight)
: base(Mathf.Ceiling(width), Mathf.Ceiling(height), false)
{
bounds = new Rectangle(x, y, width, height);
this.FillColor = fillColor;
this.strokeColor = strokeColor;
this.strokeWeight = strokeWeight;
SetXY(x, y);
Draw();
}
/// <summary>
/// Uploads general structured data into the buffer on the graphics card.
/// </summary>
/// <typeparam name="T">The type of the source data.</typeparam>
/// <param name="data">The data to upload.</param>
/// <param name="length">
/// The length of the source data to copy, in <typeparamref name="T"/>s. A value of <see cref="UInt32.MaxValue"/>
/// will auto-calculate the proper length to fill the buffer, taking into account the offset into the buffer.
/// </param>
/// <param name="srcOffset">The optional offset into the source data, in <typeparamref name="T"/>s.</param>
/// <param name="dstOffset">The optional offset into the buffer, in <typeparamref name="T"/>s.</param>
public void SetData <T>(T[] data, uint length = UInt32.MaxValue, uint srcOffset = 0, uint dstOffset = 0)
where T : struct
{
uint typeSize = (uint)Marshal.SizeOf <T>();
if (length == UInt32.MaxValue)
{
length = (uint)Mathf.Ceiling((Size - dstOffset) / (float)typeSize);
}
SetDataInternal(data, length, srcOffset, dstOffset * typeSize);
}
IEnumerator SpawnBullets()
{
while (true)
{
// wait
float delay = Mathf.Ceiling(0.5f - _elapsedTime * 0.01f);
yield return(Delay(delay));
// spawn bullet
float PADDING = 10.0f;
Vector2f bulletPos = new Vector2f(Mathf.Random(PADDING, Graphics.Width - PADDING), Graphics.Height + PADDING);
AddBullet(bulletPos, false);
}
}
public Button(float x, float y, float width, float height, string buttonText, ButtonStyle buttonStyle, Action onClick = null, Action onMouseEnter = null, Action onMouseLeave = null, Action onMousePress = null, Action onMouseRelease = null)
: base(Mathf.Ceiling(width), Mathf.Ceiling(height), false)
{
bounds = new Rectangle(x, y, width, height);
ButtonText = buttonText;
this.buttonStyle = buttonStyle;
OnClick += onClick;
OnMouseEnter += onMouseEnter;
OnMouseLeave += onMouseLeave;
OnMousePress += onMousePress;
OnMouseRelease += onMouseRelease;
SetXY(x, y);
Draw();
}
//--------------------------------------------------------------------------------------------
// REGION: public static utility methods, related to creating and placing GXPEngine objects
// based on data from Tiled Objects.
//--------------------------------------------------------------------------------------------
/// <summary>
/// Creates an EasyDraw for displaying text, based on the configuration parameters of a
/// Tiled object. (Including font, text alignment, color)
/// </summary>
/// <param name="obj">The Tiled (text) object</param>
/// <returns></returns>
public static EasyDraw CreateTextField(TiledObject obj, bool addCollider = true, bool highQualityText = true)
{
float scaleMultiplier = highQualityText ? 2 : 1; // 1=as is. 2=better antialiasing, but 4 x size
EasyDraw message = new EasyDraw((int)Mathf.Ceiling(obj.Width * scaleMultiplier), (int)Mathf.Ceiling(obj.Height * scaleMultiplier), addCollider);
// TODO: Cache fonts?
// Set Font:
FontStyle f = FontStyle.Regular;
if (obj.textField.bold == 1 && obj.textField.italic == 1)
{
f = FontStyle.Bold | FontStyle.Italic;
}
else if (obj.textField.bold == 0 && obj.textField.italic == 1)
{
f = FontStyle.Italic;
}
else if (obj.textField.bold == 1 && obj.textField.italic == 0)
{
f = FontStyle.Bold;
}
message.TextFont(new Font(obj.textField.font, Mathf.Round(obj.textField.fontSize * scaleMultiplier), f, GraphicsUnit.Pixel));
message.graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit; //AntiAlias;
// Set text alignment:
message.TextAlign(
obj.textField.horizontalAlign == "left" ? CenterMode.Min : (obj.textField.horizontalAlign == "right" ? CenterMode.Max : CenterMode.Center),
obj.textField.verticalAlign == "top" ? CenterMode.Min : (obj.textField.verticalAlign == "bottom" ? CenterMode.Max : CenterMode.Center)
);
// Set color:
uint col = obj.textField.Color;
message.Fill(Color.FromArgb((int)(col & 255), (int)((col >> 24) & 255), (int)((col >> 16) & 255), (int)((col >> 8) & 255)), (int)(col & 255));
return(message);
}
private Brush GetHealthBrushColor()
{
// more than 75% and lower or equal than 100%;
if (_player.GetHealth() > (Mathf.Ceiling(Convert.ToSingle(_player.GetMaxHealth()) / 100 * 75)) && _player.GetHealth() <= _player.GetMaxHealth())
{
_healthBrushColor = Brushes.Green;
// more or equal than 25% and less than 75%
}
else if (_player.GetHealth() > (Mathf.Ceiling(Convert.ToSingle(_player.GetMaxHealth()) / 100 * 25)) && _player.GetHealth() <= (Mathf.Floor(Convert.ToSingle(_player.GetMaxHealth()) / 100 * 75)))
{
_healthBrushColor = Brushes.OrangeRed;
_playerInfo.graphics.DrawImage(Image.FromFile("assets\\faces\\face2.png"), 15, 15, 100, 100);
// more or equal than 0% and less than 25%
}
else if (_player.GetHealth() >= (Convert.ToSingle(_player.GetMaxHealth()) - _player.GetMaxHealth()) && _player.GetHealth() <= (Mathf.Floor(Convert.ToSingle(_player.GetMaxHealth()) / 100 * 25)))
{
_healthBrushColor = Brushes.Red;
_playerInfo.graphics.DrawImage(Image.FromFile("assets\\faces\\face3.png"), 15, 15, 100, 100);
}
return(_healthBrushColor);
}
void BuildFont()
{
string charSet = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~éèêëôöàçÔÖÂÊÉœûüù";
m_fontRectangles = new Rectangle[charSet.Length];
for (int charIndex = 0; charIndex < charSet.Length; charIndex++)
{
char C = charSet[charIndex];
int index = (int)C;
m_char2Index[index] = charIndex;
}
#if BUILD_FONTS
using (Font F = new Font(this.Font.FontFamily, 36.0f)) {
// Build small bitmap and write each character
int width = 0;
int maxheight = 0;
using (Bitmap B = new Bitmap(70, 70, System.Drawing.Imaging.PixelFormat.Format32bppArgb)) {
using (Graphics G = Graphics.FromImage(B)) {
for (int i = 0; i < charSet.Length; i++)
{
string s = charSet.Substring(i, 1);
// G.FillRectangle( Brushes.Black, 0, 0, B.Width, B.Height );
// G.DrawString( s, F, Brushes.White, new PointF( 0, 0 ) );
SizeF tempSize = G.MeasureString(s, F);
m_fontRectangles[i] = new Rectangle(width, 0, (int)Mathf.Ceiling(tempSize.Width), (int)Mathf.Ceiling(tempSize.Height));
if (m_fontRectangles[i].Width > B.Width || m_fontRectangles[i].Height > B.Height)
{
throw new Exception("Fonts are too big, expand bitmap size or reduce font size!");
}
width += m_fontRectangles[i].Width;
maxheight = Math.Max(maxheight, m_fontRectangles[i].Height);
}
}
}
// Build the final bitmap
using (Bitmap B = new Bitmap(width, maxheight, System.Drawing.Imaging.PixelFormat.Format32bppArgb)) {
using (Graphics G = Graphics.FromImage(B)) {
G.FillRectangle(Brushes.Black, 0, 0, B.Width, B.Height);
for (int i = 0; i < charSet.Length; i++)
{
string s = charSet.Substring(i, 1);
G.DrawString(s, F, Brushes.White, new PointF(m_fontRectangles[i].X, m_fontRectangles[i].Y));
}
using (ImageUtility.ImageFile file = new ImageUtility.ImageFile(B, new ImageUtility.ColorProfile(ImageUtility.ColorProfile.STANDARD_PROFILE.sRGB))) {
file.Save(new FileInfo("Atlas.png"), ImageUtility.ImageFile.FILE_FORMAT.PNG);
}
}
}
}
// Write char sizes
using (FileStream S = new FileInfo("Atlas.rect").Create())
using (BinaryWriter W = new BinaryWriter(S)) {
for (int i = 0; i < m_fontRectangles.Length; i++)
{
W.Write(m_fontRectangles[i].X);
W.Write(m_fontRectangles[i].Y);
W.Write(m_fontRectangles[i].Width);
W.Write(m_fontRectangles[i].Height);
}
}
#endif
// Load atlas & rectangles
using (ImageUtility.ImageFile file = new ImageUtility.ImageFile(new FileInfo("Atlas.png"))) {
ImageUtility.ImageFile file2 = new ImageUtility.ImageFile(file, ImageUtility.PIXEL_FORMAT.RGBA8);
using (ImageUtility.ImagesMatrix M = new ImageUtility.ImagesMatrix(file2, ImageUtility.ImagesMatrix.IMAGE_TYPE.sRGB)) {
m_tex_FontAtlas = new Texture2D(m_device, M, ImageUtility.COMPONENT_FORMAT.UNORM_sRGB);
}
}
using (FileStream S = new FileInfo("Atlas.rect").OpenRead())
using (BinaryReader R = new BinaryReader(S)) {
// Read both CPU and GPU versions
float recW = 1.0f / m_tex_FontAtlas.Width;
float recH = 1.0f / m_tex_FontAtlas.Height;
using (PixelsBuffer content = new PixelsBuffer((uint)(16 * m_fontRectangles.Length))) {
using (BinaryWriter W = content.OpenStreamWrite()) {
for (int i = 0; i < m_fontRectangles.Length; i++)
{
m_fontRectangles[i].X = R.ReadInt32();
m_fontRectangles[i].Y = R.ReadInt32();
m_fontRectangles[i].Width = R.ReadInt32();
m_fontRectangles[i].Height = R.ReadInt32();
W.Write(recW * (float)m_fontRectangles[i].X);
W.Write(recH * (float)m_fontRectangles[i].Y);
W.Write(recW * (float)m_fontRectangles[i].Width);
W.Write(recH * (float)m_fontRectangles[i].Height);
}
}
m_tex_FontRectangle = new Texture2D(m_device, (uint)m_fontRectangles.Length, 1, 1, 1, ImageUtility.PIXEL_FORMAT.RGBA32F, ImageUtility.COMPONENT_FORMAT.AUTO, false, false, new PixelsBuffer[] { content });
}
}
}
private void buttonStepSimulation_Click(object sender, EventArgs e)
{
if (m_simulationIteration < 0)
{
buttonResetSimulation_Click(sender, e);
}
m_simulationIteration++;
if (radioButtonSearchAlgo0.Checked)
{
//////////////////////////////////////////////////////////////////////////
// Local search: Select second highest value from last search position
float largestValue = 0.0f;
float secondLargestValue = 0.0f;
int sX = m_simulationX, sY = m_simulationY;
int X = m_simulationX, Y = m_simulationY;
for (int i = 0; i < 8; i++)
{
int tempX = m_simulationX + dXY[i][0];
int tempY = m_simulationY + dXY[i][1];
if (tempX < 0 || tempX >= GRAPH_SIZE)
{
continue;
}
if (tempY < 0 || tempY >= GRAPH_SIZE)
{
continue;
}
if (m_visited[tempX, tempY])
{
continue; // Already visited
}
float value = m_bufferHeat[tempX, tempY].x;
if (value <= largestValue)
{
continue;
}
sX = X; sY = Y;
secondLargestValue = largestValue;
X = tempX; Y = tempY;
largestValue = value;
}
//sX = X; sY = Y;
// Write a single pixel
m_bufferSearchResults[sX, sY] = 0x000000FFU;
m_visited[sX, sY] = true;
m_visited[X, Y] = true; // Also mark maximum as visited to avoid getting trapped
m_simulationX = sX;
m_simulationY = sY;
}
else if (radioButtonSearchAlgo1.Checked)
{
//////////////////////////////////////////////////////////////////////////
// Global search: the search radius is increased and we examine all pixels within the radius and select the one with the highest value
m_simulationRadius += 1.0f;
Point center = m_simulationHotSpots[integerTrackbarControlStartPosition.Value];
// Walk the circle and find the largest value
float largestValue = 0.0f;
int X = 0, Y = 0;
uint pixelsCount = (uint)Mathf.Ceiling(Mathf.TWOPI * m_simulationRadius);
for (uint pixelIndex = 0; pixelIndex < pixelsCount; pixelIndex++)
{
float angle = pixelIndex * Mathf.TWOPI / pixelsCount;
int tempX = center.X + (int)Mathf.Floor(m_simulationRadius * Mathf.Cos(angle));
int tempY = center.Y + (int)Mathf.Floor(m_simulationRadius * Mathf.Sin(angle));
if (tempX < 0 || tempX >= GRAPH_SIZE)
{
continue;
}
if (tempY < 0 || tempY >= GRAPH_SIZE)
{
continue;
}
float heat = m_bufferHeat[tempX, tempY].x;
if (heat <= largestValue)
{
continue;
}
largestValue = heat;
X = tempX;
Y = tempY;
}
// Write a single pixel
m_bufferSearchResults[X, Y] = 0x000000FFU;
}
// Update search results texture
if (sender != null)
{
UpdateSearchResults();
}
}
public Image(float x, float y, float width, float height, Sprite image) : base(Mathf.Ceiling(width), Mathf.Ceiling(height), false)
{
bounds = new Rectangle(x, y, width, height);
useSprite = true;
sprite = image;
Draw();
SetXY(x, y);
}
/// <summary> /// Gets the size of the format in terms of binding slots in a shader. /// </summary> /// <param name="fmt">The format to get the size for.</param> /// <param name="arrSize">The number of elements in the array, if the type is an array.</param> /// <returns>The size of the format, in shader binding slots.</returns> /// <remarks>A shader binding slot is 16 bytes on basically all hardware.</remarks> public static uint GetBindingSize(this VertexElementFormat fmt, uint arrSize = 1) => (uint)Mathf.Ceiling(GetSize(fmt, arrSize) / 16.0f);
public void Compute(uint _X, uint _Y)
{
float2 __Position = new float2(0.5f + _X, 0.5f + _Y);
float2 UV = __Position / m_resolution;
uint pixelPositionX = (uint)Mathf.Floor(__Position.x);
uint pixelPositionY = (uint)Mathf.Floor(__Position.y);
float noise = 0.0f; //_tex_blueNoise[pixelPosition & 0x3F];
//PerformIntegrationTest();
// Setup camera ray
float3 csView = BuildCameraRay(UV);
float Z2Distance = csView.Length;
csView /= Z2Distance;
float3 wsView = (new float4(csView, 0.0f) * m_camera2World).xyz;
// Read back depth, normal & central radiance value from last frame
float Z = FetchDepth(__Position, 0.0f);
Z -= 1e-2f; // Prevent acnea by offseting the central depth closer
// float distance = Z * Z2Distance;
float3 wsNormal = m_arrayNormal[0][pixelPositionX, pixelPositionY].xyz.Normalized;
// Read back last frame's radiance value that we always can use as a default for neighbor areas
float3 centralRadiance = m_arrayIrradiance[0][pixelPositionX, pixelPositionY].xyz;
// Compute local camera-space
float3 wsPos = m_camera2World[3].xyz + Z * Z2Distance * wsView;
float3 wsRight = wsView.Cross(m_camera2World[1].xyz).Normalized;
float3 wsUp = wsRight.Cross(wsView);
float3 wsAt = -wsView;
float4x4 localCamera2World = new float4x4(new float4(wsRight, 0), new float4(wsUp, 0), new float4(wsAt, 0), new float4(wsPos, 1));
// Compute local camera-space normal
float3 N = new float3(wsNormal.Dot(wsRight), wsNormal.Dot(wsUp), wsNormal.Dot(wsAt));
N.z = Math.Max(1e-4f, N.z); // Make sure it's never 0!
// float3 T, B;
// BuildOrthonormalBasis( N, T, B );
// Compute screen radius of gather sphere
float screenSize_m = 2.0f * Z * TAN_HALF_FOV; // Vertical size of the screen in meters when extended to distance Z
float sphereRadius_pixels = m_resolution.y * m_gatherSphereMaxRadius_m / screenSize_m;
sphereRadius_pixels = Mathf.Min(GATHER_SPHERE_MAX_RADIUS_P, sphereRadius_pixels); // Prevent it to grow larger than our fixed limit
float radiusStepSize_pixels = Mathf.Max(1.0f, sphereRadius_pixels / MAX_SAMPLES); // This gives us our radial step size in pixels
uint samplesCount = Mathf.Clamp((uint)Mathf.Ceiling(sphereRadius_pixels / radiusStepSize_pixels), 1, MAX_SAMPLES); // Reduce samples count if possible
float radiusStepSize_meters = sphereRadius_pixels * screenSize_m / (samplesCount * m_resolution.y); // This gives us our radial step size in meters
// Start gathering radiance and bent normal by subdividing the screen-space disk around our pixel into Z slices
float4 GATHER_DEBUG = float4.Zero;
float3 sumIrradiance = float3.Zero;
float3 csAverageBentNormal = float3.Zero;
// float averageConeAngle = 0.0f;
// float varianceConeAngle = 0.0f;
float sumAO = 0.0f;
for (uint angleIndex = 0; angleIndex < MAX_ANGLES; angleIndex++)
{
float phi = (angleIndex + noise) * Mathf.PI / MAX_ANGLES;
//phi = 0.0f;
float2 csDirection;
csDirection.x = Mathf.Cos(phi);
csDirection.y = Mathf.Sin(phi);
// Gather irradiance and average cone direction for that slice
float3 csBentNormal;
float2 coneAngles;
float AO;
sumIrradiance += GatherIrradiance(csDirection, localCamera2World, N, radiusStepSize_meters, samplesCount, Z, centralRadiance, out csBentNormal, out coneAngles, out AO, ref GATHER_DEBUG);
// if ( AO < -0.01f || AO > 1.01f )
// throw new Exception( "MERDE!" );
csAverageBentNormal += csBentNormal;
sumAO += AO;
// // We're using running variance computation from https://www.johndcook.com/blog/standard_deviation/
// // Avg(N) = Avg(N-1) + [V(N) - Avg(N-1)] / N
// // S(N) = S(N-1) + [V(N) - Avg(N-1)] * [V(N) - Avg(N)]
// // And variance = S(finalN) / (finalN-1)
// //
// float previousAverageConeAngle = averageConeAngle;
// averageConeAngle += (coneAngles.x - averageConeAngle) / (2*angleIndex+1);
// varianceConeAngle += (coneAngles.x - previousAverageConeAngle) * (coneAngles.x - averageConeAngle);
//
// previousAverageConeAngle = averageConeAngle;
// averageConeAngle += (coneAngles.y - averageConeAngle) / (2*angleIndex+2);
// varianceConeAngle += (coneAngles.y - previousAverageConeAngle) * (coneAngles.y - averageConeAngle);
}
// Finalize bent cone & irradiance
csAverageBentNormal = csAverageBentNormal.Normalized;
//csAverageBentNormal *= Mathf.PI / MAX_ANGLES;
sumIrradiance *= Mathf.PI / MAX_ANGLES;
// varianceConeAngle /= 2.0f*MAX_ANGLES - 1.0f;
// float stdDeviation = Mathf.Sqrt( varianceConeAngle );
sumAO /= 2.0f * MAX_ANGLES;
//if ( sumAO < 0.0f || sumAO > 1.0f )
// throw new Exception( "MERDE!" );
float averageConeAngle = Mathf.Acos(1.0f - sumAO);
float varianceConeAngle = 0.0f; // Unfortunately, we don't have a proper value for the variance anymore... :'(
float stdDeviation = Mathf.Sqrt(varianceConeAngle);
sumIrradiance.Max(float3.Zero);
//////////////////////////////////////////////////////////////////////////
// Finalize results
m_sumIrradiance = new float4(sumIrradiance, 0);
m_bentCone = new float4(Mathf.Max(0.01f, Mathf.Cos(averageConeAngle)) * csAverageBentNormal, 1.0f - stdDeviation / (0.5f * Mathf.PI));
float3 DEBUG_VALUE = new float3(1, 0, 1);
DEBUG_VALUE = csAverageBentNormal;
DEBUG_VALUE = csAverageBentNormal.x * wsRight - csAverageBentNormal.y * wsUp - csAverageBentNormal.z * wsAt; // World-space normal
//DEBUG_VALUE = cos( averageConeAngle );
//DEBUG_VALUE = dot( ssAverageBentNormal, N );
//DEBUG_VALUE = 0.01 * Z;
//DEBUG_VALUE = sphereRadius_pixels / GATHER_SPHERE_MAX_RADIUS_P;
//DEBUG_VALUE = 0.1 * (radiusStepSize_pixels-1);
//DEBUG_VALUE = 0.5 * float(samplesCount) / MAX_SAMPLES;
//DEBUG_VALUE = varianceConeAngle;
//DEBUG_VALUE = stdDeviation;
//DEBUG_VALUE = float3( GATHER_DEBUG.xy, 0 );
//DEBUG_VALUE = float3( GATHER_DEBUG.zw, 0 );
DEBUG_VALUE = GATHER_DEBUG.xyz;
//DEBUG_VALUE = N;
//m_bentCone = float4( DEBUG_VALUE, 1 );
//////////////////////////////////////////////////////////////////////////
// Finalize bent code debug info
m_wsConePosition = wsPos;
m_wsConeDirection = csAverageBentNormal.x * wsRight + csAverageBentNormal.y * wsUp + csAverageBentNormal.z * wsAt;
//m_wsConeDirection = wsNormal;
m_averageConeAngle = averageConeAngle;
m_stdDeviation = stdDeviation;
}
