Exemplo n.º 1
0
        static string GetTransformation(Param.MtxFlags flags)
        {
            switch (flags)
            {
            case Param.MtxFlags.Position:  return($"Draw.Translate( pos )");                   // position only, no rotation

            case Param.MtxFlags.Angle:     return($"Draw.Rotate( angle )");                    // angle only, no rotation (TMP)

            case Param.MtxFlags.PosRot:    return($"Draw.Matrix *= Matrix4x4.TRS( pos, rot, Vector3.one )");

            case Param.MtxFlags.PosNormal: return($"Draw.Matrix *= Matrix4x4.TRS( pos, Quaternion.LookRotation( normal ), Vector3.one )");

            case Param.MtxFlags.PosAngle:  return($"Draw.Translate( pos );\n{fBodyIndent}Draw.Rotate( angle )");                    // pos + z angle (TMP)

            default:
                Debug.LogWarning($"Invalid matrix configuration: {flags.ToString()}");
                return("");
            }
        }
Exemplo n.º 2
0
        string GetOverloadStr(List <Param> overloadParams)
        {
            // docs
            string inlineDocs = $"/// <summary>{summary}</summary>";

            // actual function
            string overloadParamsStr = string.Join(", ", overloadParams.Select(p => p.FullMethodSig));

            // matrix setup and documentation depends only on input parameters
            Param.MtxFlags mtxFlags = Param.MtxFlags.None;
            overloadParams.ForEach(p => mtxFlags   |= p.mtxFlags);
            overloadParams.ForEach(p => inlineDocs += $"<param name=\"{p.methodSigName}\">{p.desc.Replace( "[OBJECTNAME]", objectName.ToLower() )}</param>");

            // foreach argument in the target function call
            string callParams = "";

            foreach (TargetArg arg in targetCall.args)
            {
                Param overloadParam = overloadParams.FirstOrDefault(p => p.targetArgNames.Contains(arg.name));
                if (overloadParam != null)                    // see if we have an overload param
                {
                    callParams += overloadParam.methodCallStr;
                }
                else if (constAssigns.ContainsKey(arg.name))                      // see if we have any constant arguments
                {
                    callParams += constAssigns[arg.name];
                }
                else if (arg.HasDefault)                  // see if we have a default value
                {
                    callParams += arg.@default;
                }
                else                 // else default to error :c
                {
                    callParams += $"<color=#f00>[MISSING {arg.name}]</color>";
                }

                callParams += ", ";
            }

            callParams = callParams.Substring(0, callParams.Length - 2);               // remove last comma

            if (string.IsNullOrEmpty(overloadParamsStr) == false)
            {
                overloadParamsStr = $" {overloadParamsStr} ";                 // formatting, make empty ones not have spaces inside
            }
            string functionHeader = $"\t\t{inlineDocs}\n\t\tpublic static void {overloadName}({overloadParamsStr})";
            string drawFuncCall   = CodegenDrawOverloads.DEBUG_WRITE_EMPTY_BODIES ? "_ = 0" : $"{targetCall.name}( {callParams} )";

            if (mtxFlags == Param.MtxFlags.None)
            {
                // inline function body
                return($"{functionHeader} => {drawFuncCall};");
            }
            else
            {
                // multi-line function body
                return($"{functionHeader} {{\n" +
                       $"{fBodyIndent}Draw.PushMatrix();\n" +
                       $"{fBodyIndent}{GetTransformation( mtxFlags )};\n" +
                       $"{fBodyIndent}{drawFuncCall};\n" +
                       $"{fBodyIndent}Draw.PopMatrix();\n" +
                       $"\t\t}}");
            }
        }