Exemple #1
0
        static void TestSharedVertexBlack(VertexType vertexType, ShaderStage stage)
        {
            var gen      = new ShaderBlackGenerator();
            var bytecode = gen.GenerateSharedVertexShader(vertexType, stage).Bytecode;

            WriteShaderFile($"generated_shader_black_{stage.ToString().ToLower()}_{vertexType.ToString().ToLower()}.glvs", D3DCompiler.Disassemble(bytecode));
        }
    public static void DrawDiagonal()
    {
        sortedList = Points.OrderByDescending(v => v.y).ToList();
        MaxIndex   = Points.IndexOf(sortedList.Last());
        MinIndex   = Points.IndexOf(sortedList.First());
        int MostLeftPointIndex = Points.IndexOf(Points.OrderBy(v => v.x).First());

        LeftChain = ((MinIndex < MostLeftPointIndex && MostLeftPointIndex < MaxIndex) || (MaxIndex < MostLeftPointIndex && MostLeftPointIndex < MinIndex));

        for (int i = 0; i < sortedList.Count; i++)
        {
            int        TargetIndex = Points.IndexOf(sortedList[i]);
            Vector3    o           = sortedList[i];
            Vector3    a           = GetListElementWithLoop(Points, TargetIndex - 1);
            Vector3    b           = GetListElementWithLoop(Points, TargetIndex + 1);
            VertexType t           = GetVertexType(a, o, b);
            Debug.Log("Target Vertex : " + TargetIndex + t.ToString() + ", o : " + o + ", a : " + a + ", b : " + b);
            switch (t)
            {
            case VertexType.StartVertex: HandleStartVertex(TargetIndex); break;

            case VertexType.SplitVertex: HandleSplitVertex(TargetIndex); break;

            case VertexType.MergeVertex: HandleMergeVertex(TargetIndex); break;

            case VertexType.RegularVertex: HandleRegularVertex(TargetIndex); break;

            case VertexType.EndVertex: HandleEndVertex(TargetIndex); break;
            }
        }
    }
        public static string GetTestSharedVertexShader(VertexType vertex, ShaderStage stage)
        {
            var vertexShaderPath = Path.Combine(ReferencePath, $"{ShaderType}_shared_vertex_shaders.glvs");

            vertexShaderPath = Path.Combine(vertexShaderPath, $"{vertex.ToString().ToLower()}");
            vertexShaderPath = Path.Combine(vertexShaderPath, $"{stage.ToString().ToLower()}.shared_vertex_shader");
            return(vertexShaderPath);
        }
Exemple #4
0
        static void TestSharedVertexShader(ShaderType shaderType, VertexType vertexType, ShaderStage stage)
        {
            IShaderGenerator generator = GetShaderGenerator(shaderType);

            if (generator.IsEntryPointSupported(stage) && generator.IsVertexShaderShared(stage) && generator.IsVertexFormatSupported(vertexType))
            {
                var bytecode    = generator.GenerateSharedVertexShader(vertexType, stage).Bytecode;
                var disassembly = D3DCompiler.Disassemble(bytecode);
                WriteShaderFile($"generated_{stage.ToString().ToLower()}_{vertexType.ToString().ToLower()}.glvs", disassembly);
            }
        }
 public static D3D.SHADER_MACRO CreateVertexMacro(string name, VertexType type)
 {
     return(new D3D.SHADER_MACRO {
         Name = name, Definition = $"{type.ToString().ToUpper()}_VERTEX"
     });
 }
Exemple #6
0
 public override void LoadModel()
 {
     base.LoadModel();
     mainModel.name = type.ToString() + "_" + Id;
     SetPosition();
 }
        public static void DisplayVertexShaderTestResults(bool success, VertexType vertex, ShaderStage stage, bool usesD3DX)
        {
            if (IgnoreD3DX && usesD3DX)
            {
                return;
            }

            if (!success)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"Generated shader for {stage.ToString().ToLower()} vertex format {vertex.ToString().ToLower()} is not identical to reference." + (usesD3DX ? " USES D3DX." : ""));
                Console.ResetColor();
            }
            else
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine($"Generated shader for {stage.ToString().ToLower()} vertex format {vertex.ToString().ToLower()} is identical to reference.");
                Console.ResetColor();
            }
        }