public void Execute(int i) { Vector4 *resultV = (Vector4 *)(((byte *)result) + (i * outputByteStride)); byte * off = input + (i * inputByteStride); *resultV = *((Vector4 *)off); }
public unsafe static int CheckAndWriteTriangle(Vector4 *a, Vector4 *b, Vector4 *c, ref byte *p) { Vector3 A, B, C; Vector3 N; Vector3 *pVector3 = (Vector3 *)p; if (float.IsNaN(a->W) || float.IsNaN(b->W) || float.IsNaN(c->W)) { return(0); } else { A = *(Vector3 *)a; B = *(Vector3 *)b; C = *(Vector3 *)c; A.Y = -A.Y; B.Y = -B.Y; C.Y = -C.Y; N = Vector3.Cross(B - A, C - A); N.Normalize(); *pVector3++ = N; *pVector3++ = A * ExportScale; *pVector3++ = B * ExportScale; *pVector3++ = C * ExportScale; p += 50; return(1); } }
public Data(Buffer2D <Vector4> buffer) { this.pointer = (Vector4 *)buffer.Pin(); this.pinnable = Unsafe.As <Pinnable <Vector4> >(buffer.Array); this.array = buffer.Array; this.width = buffer.Width; }
public unsafe void WritePixel(Vector2Int *uvs, int pixelCount, Vector4 *colors) { for (int i = 0; i < pixelCount; i++) { _pixels[UVToIndex(uvs[i].X, uvs[i].Y)].Write(colors[i]); } }
public unsafe void SetLightData(Vector4 *positions, int count) { if (lightsPosition != -1) { shader.SetVector4Array(lightsPosition, positions, count); } }
public static unsafe float MaxComponent(this Vector <float> v) { int v4c = Vector <float> .Count / 4; if (v4c > 1 && Vector <float> .Count == v4c * 4) { Vector4 *v4p = (Vector4 *)&v; float max = v4p[0].MaxComponent(); for (int i = 1; i < v4c; i++) { max = Math.Max(max, v4p[i].MaxComponent()); } return(max); } else { float max = v[0]; for (int i = 0; i < Vector <float> .Count; i++) { max = Math.Max(max, v[i]); } return(max); } }
void RenderParticles(IntPtr particles, IntPtr velocities, IntPtr phases) { //List<RMPrimitive> prims = _memoryManager.RM_Prims; List <RMObj> renderList = _rayMarcher.RenderList; Vector4 particle; Vector3 velocity; unsafe { Vector4 *particlesPtr = (Vector4 *)particles; Vector3 *velocitiesPtr = (Vector3 *)velocities; for (int i = 0; i < 28; ++i) { particle = particlesPtr[i]; velocity = velocitiesPtr[i]; //velocity += new Vector3(0.0f, -9.81f, 0.0f) * Time.deltaTime; //prims[i].transform.localPosition += velocity;// * Time.deltaTime; renderList[i].transform.position = new Vector3(particle.x, particle.y, particle.z); renderList[i].transform.position += velocity; Debug.Log("Position: " + particle.ToString()); Debug.Log("Velocity: " + velocity.ToString()); } } }
protected override void CapacityChanged() { unsafe { m_Ptr = (Vector4 *)m_AlignedPtr.ToPointer(); } }
public unsafe void AliasTest() { Vector4 expected = new Vector4(1, 2, 3, 4); Vector4 *ptr = &expected; using (IGorgonPointer buffer = new GorgonPointerAliasTyped <Vector4>(ptr)) { Assert.AreEqual(16, buffer.Size); float value1 = buffer.Read <float>(); float value2 = buffer.Read <float>(8); Assert.IsTrue(1.0f.EqualsEpsilon(value1)); Assert.IsTrue(3.0f.EqualsEpsilon(value2)); } fixed(Vector2 *vec2 = &_vectors[0]) { using (IGorgonPointer buffer = new GorgonPointerAlias(vec2, Vector2.SizeInBytes * _vectors.Length)) { buffer.Write(Vector2.SizeInBytes * 16, 3.0f); buffer.Write((Vector2.SizeInBytes * 16) + sizeof(float), 4.0f); Vector2 actual = buffer.Read <Vector2>(16 * Vector2.SizeInBytes); Assert.IsTrue(_vectors[16].X.EqualsEpsilon(actual.X)); Assert.IsTrue(_vectors[16].Y.EqualsEpsilon(actual.Y)); } } }
public unsafe void SetSpotlightData(Vector4 *param, int count) { if (spotlightParamsPosition != -1) { shader.SetVector4Array(spotlightParamsPosition, param, count); } }
unsafe public void PrepareGPUShadowDatas(CullingResults cullResults, HDCamera camera) { int shadowIndex = 0; m_ShadowDatas.Clear(); // Create all HDShadowDatas and update them with shadow request datas for (int i = 0; i < m_ShadowRequestCount; i++) { HDShadowAtlas atlas = m_Atlas; if (m_ShadowRequests[i].shadowMapType == ShadowMapType.CascadedDirectional) { atlas = m_CascadeAtlas; } else if (m_ShadowRequests[i].shadowMapType == ShadowMapType.AreaLightAtlas) { atlas = m_AreaLightShadowAtlas; } HDShadowData shadowData; if (m_ShadowRequests[i].shouldUseCachedShadow) { shadowData = m_ShadowRequests[i].cachedShadowData; } else { shadowData = CreateShadowData(m_ShadowRequests[i], atlas); m_ShadowRequests[i].cachedShadowData = shadowData; } m_ShadowDatas.Add(shadowData); m_ShadowRequests[i].shadowIndex = shadowIndex++; } int first = k_DirectionalShadowCascadeCount, second = k_DirectionalShadowCascadeCount; fixed(float *sphereBuffer = m_DirectionalShadowData.sphereCascades) { Vector4 *sphere = (Vector4 *)sphereBuffer; for (int i = 0; i < k_DirectionalShadowCascadeCount; i++) { first = (first == k_DirectionalShadowCascadeCount && sphere[i].w > 0.0f) ? i : first; second = ((second == k_DirectionalShadowCascadeCount || second == first) && sphere[i].w > 0.0f) ? i : second; } } // Update directional datas: if (second != k_DirectionalShadowCascadeCount) { m_DirectionalShadowData.cascadeDirection = (GetCascadeSphereAtIndex(second) - GetCascadeSphereAtIndex(first)).normalized; } else { m_DirectionalShadowData.cascadeDirection = Vector4.zero; } m_DirectionalShadowData.cascadeDirection.w = VolumeManager.instance.stack.GetComponent <HDShadowSettings>().cascadeShadowSplitCount.value; }
public void SetVertexOffset(int offset) { _vertexPtrOffset = offset; if (InOutBufferPtr != null) { VertexPtr = (Vector4 *)(InOutBufferPtr + _vertexPtrOffset); } }
/// <summary> /// <paramref name="result"/> must differ from <paramref name="vector"/>, otherwise invoke <see cref="Mul(Matrix4x4*, Vector4*)"/> instead /// </summary> public static Vector4 *Mul(Matrix4x4 *transform, Vector4 *vector, Vector4 *result) { result->X = vector->X * transform->M11 + vector->Y * transform->M21 + vector->Z * transform->M31 + vector->W * transform->M41; result->Y = vector->X * transform->M12 + vector->Y * transform->M22 + vector->Z * transform->M32 + vector->W * transform->M42; result->Z = vector->X * transform->M13 + vector->Y * transform->M23 + vector->Z * transform->M33 + vector->W * transform->M43; result->W = vector->X * transform->M14 + vector->Y * transform->M24 + vector->Z * transform->M34 + vector->W * transform->M44; return(result); }
public Vector4 GetAttributeUnsafe(int attribId) { unsafe { Vector4 *attribPtr = (Vector4 *)m_AttributesBuffer.ToPointer() + attribId; return(*attribPtr); } }
public void Execute(int i) { Vector4 *resultV = result + i; byte * off = input + i * byteStride; *resultV = *(Vector4 *)off; (*resultV).x *= -1; (*resultV).z *= -1; }
public void SetAttributeUnsafe(int attribId, Vector4 value) { m_WasModified = true; unsafe { Vector4 *attribPtr = (Vector4 *)m_AttributesBuffer.ToPointer() + attribId; attribPtr[0] = value; } }
public unsafe static Vector4[] GetVector4sInterleaved( ref byte[] bytes, int start, int count, int byteStride ) { Profiler.BeginSample("GetVector4sInterleaved"); var res = new Vector4[count]; #if BUFFER_MEMORY_COPY fixed(Vector4 * dest = &(res[0]) ) { Vector4 *destV = dest; fixed(byte *src = &(bytes[start])) { byte *off = src; for (int i = 0; i < count; i++) { System.Buffer.MemoryCopy( off, destV, 16, 16 ); off += byteStride; destV += 1; } } } #else int elementSize = Marshal.SizeOf(typeof(Vector4)); var gcRes = GCHandle.Alloc(res, GCHandleType.Pinned); int off = start; var dest = gcRes.AddrOfPinnedObject(); for (int i = 0; i < count; i++) { Marshal.Copy(bytes, off, dest, elementSize); off += byteStride; dest += elementSize; } gcRes.Free(); #endif Profiler.EndSample(); return(res); }
private unsafe void FillSampleOffsets_Bloom(int texSize, Vector4 *ptSampleWeights, float *afTexCoordOffset, float deviation, float multiplier) { int i = 0; float tu = 1.0f / (float)texSize; // Fill the center texel float weight = multiplier * Numerics.GaussianDistribution(0, 0, deviation); ptSampleWeights[0] = new Vector4(weight, weight, weight, 1.0f); afTexCoordOffset[0] = 0.0f; // Fill the first half for (i = 1; i < 8; i++) { // Get the Gaussian intensity for this offset weight = multiplier * Numerics.GaussianDistribution((float)i, 0, deviation); afTexCoordOffset[i] = i * tu; ptSampleWeights[i] = new Vector4(weight, weight, weight, 1.0f); } // Mirror to the second half for (i = 8; i < 15; i++) { ptSampleWeights[i] = ptSampleWeights[i - 7]; afTexCoordOffset[i] = -afTexCoordOffset[i - 7]; } //int i = 0; //float tu = 1.0f / (float)texSize; //// Fill the center texel //float weight = 1.0f * Numerics.GaussianDistribution(0, mean, deviation); //ptsampleWeights[0] = new Vector4(weight, weight, weight, 1.0f); //ptafTexCoordOffset[0] = 0.0f; // // Fill the right side // for (i = 1; i < 8; i++) // { // weight = multiplier * Numerics.GaussianDistribution((float)i, mean, deviation); // ptafTexCoordOffset[i] = i * tu; // ptsampleWeights[i] = new Vector4(weight, weight, weight, 1.0f); // } // // Copy to the left side // for (i = 8; i < 15; i++) // { // ptsampleWeights[i] = ptsampleWeights[i - 7]; // ptafTexCoordOffset[i] = -ptafTexCoordOffset[i - 7]; // } }
void LateUpdate() { for (int j = 0; j < m_Meshes.Length; ++j) { Mesh m = m_Meshes[j]; Matrix4x4 t = m_MeshesImportTransform[j]; if (m_PerInstanceBuffer != IntPtr.Zero && m_InstancesCount > 0) { #if false MaterialPropertyBlock materialProp = new MaterialPropertyBlock(); Matrix4x4[] transforms = new Matrix4x4[1023]; Vector4[] colors = new Vector4[1023]; for (int i = 0; i < m_InstancesCount; i += 1023) { for (int h = 0; h + i < m_InstancesCount && h < 1023; ++h) { unsafe { Matrix4x4 *instanceTransform = (Matrix4x4 *)m_PerInstanceBuffer.ToPointer(); Vector4 * instanceColor = (Vector4 *)(instanceTransform + m_InstancesCount); transforms[h] = instanceTransform[i + h] * t; colors[h] = instanceColor[i + h]; } } int DataLeft = Math.Min(m_InstancesCount - i, 1023); materialProp.SetVectorArray(ColorPropertyName, colors); Graphics.DrawMeshInstanced(m, 0, m_Material, transforms, DataLeft, materialProp); } #else for (int i = 0; i < m_InstancesCount; i++) { Matrix4x4 transform; Vector4 color; unsafe { Matrix4x4 *instanceTransform = (Matrix4x4 *)m_PerInstanceBuffer.ToPointer(); Vector4 * instanceColor = (Vector4 *)(instanceTransform + m_InstancesCount); transform = instanceTransform[i] * t; color = instanceColor[i]; } MaterialPropertyBlock colorProperty = new MaterialPropertyBlock(); colorProperty.SetColor(ColorPropertyName, color); Graphics.DrawMesh(m, transform, m_Material, 0, null, 0, colorProperty, m_CastShadow); } #endif } } }
void DisplayButtons(string name, List <ToolbuttonData> DisplayToolButtons) { if (ImGui.Begin(name, _flags)) { uint unclickedcolor; uint clickedcolour; ImGuiCol buttonidx = ImGuiCol.Button; unsafe { Vector4 *unclickedcolorv = ImGui.GetStyleColorVec4(ImGuiCol.Button); Vector4 *clickedcolorv = ImGui.GetStyleColorVec4(ImGuiCol.ButtonActive); unclickedcolor = ImGui.ColorConvertFloat4ToU32(*unclickedcolorv); clickedcolour = ImGui.ColorConvertFloat4ToU32(*clickedcolorv); } //Store the colors for pressed and unpressed buttons uint iterations = 0; //displays the default toolbar menu icons foreach (var button in DisplayToolButtons)//For each button { string id = iterations.ToString(); ImGui.PushID(id); if (button.GetActive != null) //If the windows state can be checked { if (button.GetActive()) //If the window is open { ImGui.PushStyleColor(buttonidx, clickedcolour); //Have the button be "pressed" } else//If closed { ImGui.PushStyleColor(buttonidx, unclickedcolor);//Have the button be colored normally } } if (ImGui.ImageButton(button.Picture, BtnSizes))//Make the button { button.OnClick(); } if (ImGui.IsItemHovered()) { ImGui.SetTooltip(button.TooltipText); } ImGui.PopID(); iterations++; } ImGui.PushStyleColor(buttonidx, unclickedcolor); ImGui.End(); } }
public void Setup() { this.width = 2048; this.buffer = new Buffer2D <Vector4>(2048, 2048); this.pointer = (Vector4 *)this.buffer.Pin(); this.array = this.buffer.Array; this.pinnable = Unsafe.As <Pinnable <Vector4> >(this.array); this.startIndex = 2048 / 2 - (this.Count / 2); this.endIndex = 2048 / 2 + (this.Count / 2); }
public static void Copy(NativeArray <Vector4> nativeArray, Vector4[] arrays, int srcIndex, int destIndex, int length) { unsafe { Vector4 *src = (Vector4 *)nativeArray.GetUnsafeReadOnlyPtr(); src = src + srcIndex; fixed(Vector4 *dest = &arrays[destIndex]) { UnsafeUtility.MemCpy(dest, src, sizeof(Vector4) * length); } } }
protected unsafe JobHandle?GetTangentsJob( void *input, int count, GLTFComponentType inputType, int inputByteStride, Vector4 *output, int outputByteStride, bool normalized = false ) { Profiler.BeginSample("GetTangentsJob"); JobHandle?jobHandle; switch (inputType) { case GLTFComponentType.Float: var jobTangentI = new Jobs.GetTangentsInterleavedJob(); jobTangentI.inputByteStride = inputByteStride > 0 ? inputByteStride : 16; jobTangentI.input = (byte *)input; jobTangentI.outputByteStride = outputByteStride; jobTangentI.result = output; jobHandle = jobTangentI.Schedule(count, GLTFast.DefaultBatchCount); break; case GLTFComponentType.Short: var jobTangent = new Jobs.GetTangentsInt16NormalizedInterleavedJob(); jobTangent.inputByteStride = inputByteStride > 0 ? inputByteStride : 8;; Assert.IsTrue(normalized); jobTangent.input = (System.Int16 *)input; jobTangent.outputByteStride = outputByteStride; jobTangent.result = output; jobHandle = jobTangent.Schedule(count, GLTFast.DefaultBatchCount); break; case GLTFComponentType.Byte: var jobTangentByte = new Jobs.GetVector4sInt8NormalizedInterleavedJob(); jobTangentByte.inputByteStride = inputByteStride > 0 ? inputByteStride : 4; Assert.IsTrue(normalized); jobTangentByte.input = (sbyte *)input; jobTangentByte.outputByteStride = outputByteStride; jobTangentByte.result = output; jobHandle = jobTangentByte.Schedule(count, GLTFast.DefaultBatchCount); break; default: Debug.LogErrorFormat(GLTFast.ErrorUnsupportedType, "Tangent", inputType); jobHandle = null; break; } Profiler.EndSample(); return(jobHandle); }
public void Execute() { Vector4 *resultV = result; byte * off = input; for (int i = 0; i < count; i++) { *resultV = *(Vector4 *)off; off += byteStride; resultV += 1; } }
unsafe public void ProcessShadowRequests(CullResults cullResults, Camera camera, LightingDebugSettings lightingDebugSettings) { int shadowIndex = 0; if (lightingDebugSettings.shadowResolutionScaleFactor != 1.0f) { foreach (var shadowRequest in m_ShadowRequests) { shadowRequest.viewportSize *= lightingDebugSettings.shadowResolutionScaleFactor; } } // Assign a position to all the shadows in the atlas, and scale shadows if needed if (!m_CascadeAtlas.Layout(false)) { Debug.LogWarning("Cascade Shadow atlasing has failed, try reducing the shadow resolution of the directional light or increase the shadow atlas size"); } m_Atlas.Layout(); m_ShadowDatas.Clear(); // Create all HDShadowDatas and update them with shadow request datas foreach (var shadowRequest in m_ShadowRequests) { m_ShadowDatas.Add(CreateShadowData(shadowRequest)); shadowRequest.shadowIndex = shadowIndex++; } int first = k_DirectionalShadowCascadeCount, second = k_DirectionalShadowCascadeCount; fixed(float *sphereBuffer = m_DirectionalShadowData.sphereCascades) { Vector4 *sphere = (Vector4 *)sphereBuffer; for (int i = 0; i < k_DirectionalShadowCascadeCount; i++) { first = (first == k_DirectionalShadowCascadeCount && sphere[i].w > 0.0f) ? i : first; second = ((second == k_DirectionalShadowCascadeCount || second == first) && sphere[i].w > 0.0f) ? i : second; } } // Update directional datas: if (second != k_DirectionalShadowCascadeCount) { m_DirectionalShadowData.cascadeDirection = (GetCascadeSphereAtIndex(second) - GetCascadeSphereAtIndex(first)).normalized; } else { m_DirectionalShadowData.cascadeDirection = Vector4.zero; } m_DirectionalShadowData.cascadeDirection.w = k_DirectionalShadowCascadeCount; }
public void Execute(int i) { Vector4 *resultV = (Vector4 *)(((byte *)result) + (i * outputByteStride)); short * off = (short *)(((byte *)input) + (i * inputByteStride)); Vector4 tmp; tmp.x = Mathf.Max(*off / (float)short.MaxValue, -1f); tmp.y = Mathf.Max(*(off + 1) / (float)short.MaxValue, -1f); tmp.z = Mathf.Max(*(off + 2) / (float)short.MaxValue, -1f); tmp.w = Mathf.Max(*(off + 3) / (float)short.MaxValue, -1f); *resultV = tmp; }
internal unsafe void ConvertIntoQuaternion(Source source) { source.Lock(); Vector4 *pter = (Vector4 *)source.ArrayPointer; for (int i = 0; i < source.Accesor.Count; i++, pter++) { *pter = ConvertQuaternion(*pter); } source.Unlock(); }
public Texture giveEntireTerrainInTexture() { try { int width = TerrainGlobals.getTerrain().getNumXVerts(); int height = TerrainGlobals.getTerrain().getNumXVerts(); Texture mainTex = new Texture(BRenderDevice.getDevice(), width, height, 1, Usage.None, Format.A32B32G32R32F, Pool.Managed); Vector3[] details = TerrainGlobals.getEditor().getDetailPoints(); unsafe { GraphicsStream streamPos = mainTex.LockRectangle(0, LockFlags.None); Vector4 * pos = (Vector4 *)streamPos.InternalDataPointer; for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { int srcIndex = x * width + y; int dstIndex = x * width + y; Vector3 input = details[srcIndex]; pos[dstIndex].X = input.X; pos[dstIndex].Y = input.Y; pos[dstIndex].Z = input.Z; pos[dstIndex].W = 1; } } mainTex.UnlockRectangle(0); } return(mainTex); } catch (OutOfVideoMemoryException eGPU) { if (!CoreGlobals.IsBatchExport) { MessageBox.Show("giveEntireTerrainInTexture: You've run out of graphics card memory... Talk to the editor guys.."); } return(null); } catch (OutOfMemoryException eCPU) { if (!CoreGlobals.IsBatchExport) { MessageBox.Show("giveEntireTerrainInTexture: You've run out of memory... Talk to the editor guys.."); } return(null); } return(null); }
public unsafe Vector4 IterateUsingPointers() { Vector4 sum = new Vector4(); Vector4 *ptr = (Vector4 *)this.buffer.Pin(); Vector4 *end = ptr + this.Length; for (; ptr < end; ptr++) { sum += *ptr; } return(sum); }
public void Execute(int i) { Vector4 *resultV = (Vector4 *)(((byte *)result) + (i * outputByteStride)); sbyte * off = input + (i * inputByteStride); Vector4 tmp; tmp.x = Mathf.Max(*off / 127f, -1f); tmp.y = -Mathf.Max(*(off + 1) / 127f, -1f); tmp.z = -Mathf.Max(*(off + 2) / 127f, -1f); tmp.w = Mathf.Max(*(off + 3) / 127f, -1f); tmp.Normalize(); *resultV = tmp; }