| //////////////////////////////////////////////////////////////////////////////// |
| // Do not modify! |
| // Generated by rpcapi |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| package service |
| |
| import "fmt" |
| |
| func (c callImport) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "Import(name: %v, Data: %v)", |
| c.name, c.Data, |
| ) |
| } |
| func (r resultImport) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callGetCaptures) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "GetCaptures()") |
| } |
| func (r resultGetCaptures) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callGetDevices) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "GetDevices()") |
| } |
| func (r resultGetDevices) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callGetState) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "GetState(capture: %v, after: %v)", |
| c.capture, c.after, |
| ) |
| } |
| func (r resultGetState) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callGetHierarchy) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "GetHierarchy(capture: %v)", |
| c.capture, |
| ) |
| } |
| func (r resultGetHierarchy) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callGetMemoryInfo) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "GetMemoryInfo(capture: %v, after: %v, rng: %v)", |
| c.capture, c.after, c.rng, |
| ) |
| } |
| func (r resultGetMemoryInfo) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callGetFramebufferColor) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "GetFramebufferColor(device: %v, capture: %v, api: %v, after: %v, settings: %v)", |
| c.device, c.capture, c.api, c.after, c.settings, |
| ) |
| } |
| func (r resultGetFramebufferColor) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callGetFramebufferDepth) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "GetFramebufferDepth(device: %v, capture: %v, api: %v, after: %v)", |
| c.device, c.capture, c.api, c.after, |
| ) |
| } |
| func (r resultGetFramebufferDepth) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callGetTimingInfo) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "GetTimingInfo(device: %v, capture: %v, mask: %v)", |
| c.device, c.capture, c.mask, |
| ) |
| } |
| func (r resultGetTimingInfo) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callPrerenderFramebuffers) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "PrerenderFramebuffers(device: %v, capture: %v, api: %v, width: %v, height: %v, atomIds: %v)", |
| c.device, c.capture, c.api, c.width, c.height, c.atomIds, |
| ) |
| } |
| func (r resultPrerenderFramebuffers) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callReplaceAtom) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "ReplaceAtom(capture: %v, atomId: %v, atomType: %v, data: %v)", |
| c.capture, c.atomId, c.atomType, c.data, |
| ) |
| } |
| func (r resultReplaceAtom) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callResolveAtomStream) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "ResolveAtomStream(id: %v)", |
| c.id, |
| ) |
| } |
| func (r resultResolveAtomStream) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callResolveBinary) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "ResolveBinary(id: %v)", |
| c.id, |
| ) |
| } |
| func (r resultResolveBinary) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callResolveCapture) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "ResolveCapture(id: %v)", |
| c.id, |
| ) |
| } |
| func (r resultResolveCapture) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callResolveDevice) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "ResolveDevice(id: %v)", |
| c.id, |
| ) |
| } |
| func (r resultResolveDevice) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callResolveHierarchy) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "ResolveHierarchy(id: %v)", |
| c.id, |
| ) |
| } |
| func (r resultResolveHierarchy) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callResolveImageInfo) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "ResolveImageInfo(id: %v)", |
| c.id, |
| ) |
| } |
| func (r resultResolveImageInfo) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callResolveMemoryInfo) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "ResolveMemoryInfo(id: %v)", |
| c.id, |
| ) |
| } |
| func (r resultResolveMemoryInfo) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callResolveSchema) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "ResolveSchema(id: %v)", |
| c.id, |
| ) |
| } |
| func (r resultResolveSchema) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| func (c callResolveTimingInfo) Format(f fmt.State, r rune) { |
| fmt.Fprintf(f, "ResolveTimingInfo(id: %v)", |
| c.id, |
| ) |
| } |
| func (r resultResolveTimingInfo) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "res: %#v", r.value) |
| } |
| |
| func (h ApiId) Valid() bool { |
| return h.ID.Valid() |
| } |
| func (h AtomStreamId) Valid() bool { |
| return h.ID.Valid() |
| } |
| func (h BinaryId) Valid() bool { |
| return h.ID.Valid() |
| } |
| func (h CaptureId) Valid() bool { |
| return h.ID.Valid() |
| } |
| func (h DeviceId) Valid() bool { |
| return h.ID.Valid() |
| } |
| func (h HierarchyId) Valid() bool { |
| return h.ID.Valid() |
| } |
| func (h ImageInfoId) Valid() bool { |
| return h.ID.Valid() |
| } |
| func (h MemoryInfoId) Valid() bool { |
| return h.ID.Valid() |
| } |
| func (h SchemaId) Valid() bool { |
| return h.ID.Valid() |
| } |
| func (h TimingInfoId) Valid() bool { |
| return h.ID.Valid() |
| } |
| |
| func (a ApiIdArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]ApiIdˢ", len(a)) |
| } |
| func (a ApiSchemaArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]ApiSchemaˢ", len(a)) |
| } |
| func (a AtomGroupArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]AtomGroupˢ", len(a)) |
| } |
| func (a AtomInfoArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]AtomInfoˢ", len(a)) |
| } |
| func (a AtomRangeTimerArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]AtomRangeTimerˢ", len(a)) |
| } |
| func (a AtomTimerArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]AtomTimerˢ", len(a)) |
| } |
| func (a CaptureIdArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]CaptureIdˢ", len(a)) |
| } |
| func (a ClassInfoArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]ClassInfoˢ", len(a)) |
| } |
| func (a ClassInfoPtrArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]ClassInfoᵖˢ", len(a)) |
| } |
| func (a DeviceIdArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]DeviceIdˢ", len(a)) |
| } |
| func (a EnumEntryArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]EnumEntryˢ", len(a)) |
| } |
| func (a EnumInfoArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]EnumInfoˢ", len(a)) |
| } |
| func (a EnumInfoPtrArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]EnumInfoᵖˢ", len(a)) |
| } |
| func (a FieldInfoArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]FieldInfoˢ", len(a)) |
| } |
| func (a FieldInfoPtrArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]FieldInfoᵖˢ", len(a)) |
| } |
| func (a MemoryRangeArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]MemoryRangeˢ", len(a)) |
| } |
| func (a ParameterInfoArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]ParameterInfoˢ", len(a)) |
| } |
| func (a TypeInfoArray) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]TypeInfoˢ", len(a)) |
| } |
| func (a U64Array) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]U64ˢ", len(a)) |
| } |
| func (a U8Array) Format(f fmt.State, c rune) { |
| fmt.Fprintf(f, "[%d]U8ˢ", len(a)) |
| } |
| |
| func (i ImageFormat) IsRGBA8() bool { return i == ImageFormatRGBA8 } |
| func (i ImageFormat) IsFloat32() bool { return i == ImageFormatFloat32 } |
| func (i TimingMask) IsTimingPerCommand() bool { return i == TimingMaskTimingPerCommand } |
| func (i TimingMask) IsTimingPerDrawCall() bool { return i == TimingMaskTimingPerDrawCall } |
| func (i TimingMask) IsTimingPerFrame() bool { return i == TimingMaskTimingPerFrame } |
| func (i TypeKind) IsBool() bool { return i == TypeKindBool } |
| func (i TypeKind) IsS8() bool { return i == TypeKindS8 } |
| func (i TypeKind) IsU8() bool { return i == TypeKindU8 } |
| func (i TypeKind) IsS16() bool { return i == TypeKindS16 } |
| func (i TypeKind) IsU16() bool { return i == TypeKindU16 } |
| func (i TypeKind) IsS32() bool { return i == TypeKindS32 } |
| func (i TypeKind) IsU32() bool { return i == TypeKindU32 } |
| func (i TypeKind) IsF32() bool { return i == TypeKindF32 } |
| func (i TypeKind) IsS64() bool { return i == TypeKindS64 } |
| func (i TypeKind) IsU64() bool { return i == TypeKindU64 } |
| func (i TypeKind) IsF64() bool { return i == TypeKindF64 } |
| func (i TypeKind) IsString() bool { return i == TypeKindString } |
| func (i TypeKind) IsEnum() bool { return i == TypeKindEnum } |
| func (i TypeKind) IsStruct() bool { return i == TypeKindStruct } |
| func (i TypeKind) IsClass() bool { return i == TypeKindClass } |
| func (i TypeKind) IsArray() bool { return i == TypeKindArray } |
| func (i TypeKind) IsStaticArray() bool { return i == TypeKindStaticArray } |
| func (i TypeKind) IsMap() bool { return i == TypeKindMap } |
| func (i TypeKind) IsPointer() bool { return i == TypeKindPointer } |
| func (i TypeKind) IsMemory() bool { return i == TypeKindMemory } |
| func (i TypeKind) IsAny() bool { return i == TypeKindAny } |
| func (i TypeKind) IsID() bool { return i == TypeKindID } |
| |
| func CreateDevice( |
| Name string, |
| Model string, |
| OS string, |
| PointerSize uint8, |
| PointerAlignment uint8, |
| MaxMemorySize uint64, |
| RequiresShaderPatching bool, |
| ) *Device { |
| return &Device{ |
| Name: Name, |
| Model: Model, |
| OS: OS, |
| PointerSize: PointerSize, |
| PointerAlignment: PointerAlignment, |
| MaxMemorySize: MaxMemorySize, |
| RequiresShaderPatching: RequiresShaderPatching, |
| } |
| } |
| |
| func (c *Device) GetName() string { return c.Name } |
| func (c *Device) GetModel() string { return c.Model } |
| func (c *Device) GetOS() string { return c.OS } |
| func (c *Device) GetPointerSize() uint8 { return c.PointerSize } |
| func (c *Device) GetPointerAlignment() uint8 { return c.PointerAlignment } |
| func (c *Device) GetMaxMemorySize() uint64 { return c.MaxMemorySize } |
| func (c *Device) GetRequiresShaderPatching() bool { return c.RequiresShaderPatching } |
| |
| func CreateCapture( |
| Name string, |
| Atoms AtomStreamId, |
| Apis ApiIdArray, |
| Schema SchemaId, |
| ) *Capture { |
| return &Capture{ |
| Name: Name, |
| Atoms: Atoms, |
| Apis: Apis, |
| Schema: Schema, |
| } |
| } |
| |
| func (c *Capture) GetName() string { return c.Name } |
| func (c *Capture) GetAtoms() AtomStreamId { return c.Atoms } |
| func (c *Capture) GetApis() ApiIdArray { return c.Apis } |
| func (c *Capture) GetSchema() SchemaId { return c.Schema } |
| |
| func CreateBinary( |
| Data U8Array, |
| ) *Binary { |
| return &Binary{ |
| Data: Data, |
| } |
| } |
| |
| func (c *Binary) GetData() U8Array { return c.Data } |
| |
| func CreateAtomStream( |
| Data U8Array, |
| ) *AtomStream { |
| return &AtomStream{ |
| Data: Data, |
| } |
| } |
| |
| func (c *AtomStream) GetData() U8Array { return c.Data } |
| |
| func CreateHierarchy( |
| Root AtomGroup, |
| ) *Hierarchy { |
| return &Hierarchy{ |
| Root: Root, |
| } |
| } |
| |
| func (c *Hierarchy) GetRoot() AtomGroup { return c.Root } |
| |
| func CreateAtomGroup( |
| Name string, |
| Range AtomRange, |
| SubGroups AtomGroupArray, |
| ) *AtomGroup { |
| return &AtomGroup{ |
| Name: Name, |
| Range: Range, |
| SubGroups: SubGroups, |
| } |
| } |
| |
| func (c *AtomGroup) GetName() string { return c.Name } |
| func (c *AtomGroup) GetRange() AtomRange { return c.Range } |
| func (c *AtomGroup) GetSubGroups() AtomGroupArray { return c.SubGroups } |
| |
| func CreateAtomRange( |
| First uint64, |
| Count uint64, |
| ) *AtomRange { |
| return &AtomRange{ |
| First: First, |
| Count: Count, |
| } |
| } |
| |
| func (c *AtomRange) GetFirst() uint64 { return c.First } |
| func (c *AtomRange) GetCount() uint64 { return c.Count } |
| |
| func CreateMemoryInfo( |
| Data U8Array, |
| Stale MemoryRangeArray, |
| Current MemoryRangeArray, |
| Unknown MemoryRangeArray, |
| ) *MemoryInfo { |
| return &MemoryInfo{ |
| Data: Data, |
| Stale: Stale, |
| Current: Current, |
| Unknown: Unknown, |
| } |
| } |
| |
| func (c *MemoryInfo) GetData() U8Array { return c.Data } |
| func (c *MemoryInfo) GetStale() MemoryRangeArray { return c.Stale } |
| func (c *MemoryInfo) GetCurrent() MemoryRangeArray { return c.Current } |
| func (c *MemoryInfo) GetUnknown() MemoryRangeArray { return c.Unknown } |
| |
| func CreateMemoryRange( |
| Base uint64, |
| Size uint64, |
| ) *MemoryRange { |
| return &MemoryRange{ |
| Base: Base, |
| Size: Size, |
| } |
| } |
| |
| func (c *MemoryRange) GetBase() uint64 { return c.Base } |
| func (c *MemoryRange) GetSize() uint64 { return c.Size } |
| |
| func CreateImageInfo( |
| Format ImageFormat, |
| Width uint32, |
| Height uint32, |
| Data BinaryId, |
| ) *ImageInfo { |
| return &ImageInfo{ |
| Format: Format, |
| Width: Width, |
| Height: Height, |
| Data: Data, |
| } |
| } |
| |
| func (c *ImageInfo) GetFormat() ImageFormat { return c.Format } |
| func (c *ImageInfo) GetWidth() uint32 { return c.Width } |
| func (c *ImageInfo) GetHeight() uint32 { return c.Height } |
| func (c *ImageInfo) GetData() BinaryId { return c.Data } |
| |
| func CreateTimingInfo( |
| PerCommand AtomTimerArray, |
| PerDrawCall AtomRangeTimerArray, |
| PerFrame AtomRangeTimerArray, |
| ) *TimingInfo { |
| return &TimingInfo{ |
| PerCommand: PerCommand, |
| PerDrawCall: PerDrawCall, |
| PerFrame: PerFrame, |
| } |
| } |
| |
| func (c *TimingInfo) GetPerCommand() AtomTimerArray { return c.PerCommand } |
| func (c *TimingInfo) GetPerDrawCall() AtomRangeTimerArray { return c.PerDrawCall } |
| func (c *TimingInfo) GetPerFrame() AtomRangeTimerArray { return c.PerFrame } |
| |
| func CreateAtomTimer( |
| AtomId uint64, |
| Nanoseconds uint64, |
| ) *AtomTimer { |
| return &AtomTimer{ |
| AtomId: AtomId, |
| Nanoseconds: Nanoseconds, |
| } |
| } |
| |
| func (c *AtomTimer) GetAtomId() uint64 { return c.AtomId } |
| func (c *AtomTimer) GetNanoseconds() uint64 { return c.Nanoseconds } |
| |
| func CreateAtomRangeTimer( |
| FromAtomId uint64, |
| ToAtomId uint64, |
| Nanoseconds uint64, |
| ) *AtomRangeTimer { |
| return &AtomRangeTimer{ |
| FromAtomId: FromAtomId, |
| ToAtomId: ToAtomId, |
| Nanoseconds: Nanoseconds, |
| } |
| } |
| |
| func (c *AtomRangeTimer) GetFromAtomId() uint64 { return c.FromAtomId } |
| func (c *AtomRangeTimer) GetToAtomId() uint64 { return c.ToAtomId } |
| func (c *AtomRangeTimer) GetNanoseconds() uint64 { return c.Nanoseconds } |
| |
| func CreateRenderSettings( |
| MaxWidth uint32, |
| MaxHeight uint32, |
| Wireframe bool, |
| ) *RenderSettings { |
| return &RenderSettings{ |
| MaxWidth: MaxWidth, |
| MaxHeight: MaxHeight, |
| Wireframe: Wireframe, |
| } |
| } |
| |
| func (c *RenderSettings) GetMaxWidth() uint32 { return c.MaxWidth } |
| func (c *RenderSettings) GetMaxHeight() uint32 { return c.MaxHeight } |
| func (c *RenderSettings) GetWireframe() bool { return c.Wireframe } |
| |
| func CreateSchema( |
| Atoms AtomInfoArray, |
| Apis ApiSchemaArray, |
| ) *Schema { |
| return &Schema{ |
| Atoms: Atoms, |
| Apis: Apis, |
| } |
| } |
| |
| func (c *Schema) GetAtoms() AtomInfoArray { return c.Atoms } |
| func (c *Schema) GetApis() ApiSchemaArray { return c.Apis } |
| |
| func CreateApiSchema( |
| Api ApiId, |
| State StructInfo, |
| ) *ApiSchema { |
| return &ApiSchema{ |
| Api: Api, |
| State: State, |
| } |
| } |
| |
| func (c *ApiSchema) GetApi() ApiId { return c.Api } |
| func (c *ApiSchema) GetState() StructInfo { return c.State } |
| |
| func CreateArrayInfo( |
| Name string, |
| Kind TypeKind, |
| ElementType TypeInfo, |
| ) *ArrayInfo { |
| return &ArrayInfo{ |
| Name: Name, |
| Kind: Kind, |
| ElementType: ElementType, |
| } |
| } |
| |
| func (c *ArrayInfo) GetName() string { return c.Name } |
| func (c *ArrayInfo) GetKind() TypeKind { return c.Kind } |
| func (c *ArrayInfo) GetElementType() TypeInfo { return c.ElementType } |
| |
| func CreateStaticArrayInfo( |
| Name string, |
| Kind TypeKind, |
| ElementType TypeInfo, |
| Size uint32, |
| ) *StaticArrayInfo { |
| return &StaticArrayInfo{ |
| Name: Name, |
| Kind: Kind, |
| ElementType: ElementType, |
| Size: Size, |
| } |
| } |
| |
| func (c *StaticArrayInfo) GetName() string { return c.Name } |
| func (c *StaticArrayInfo) GetKind() TypeKind { return c.Kind } |
| func (c *StaticArrayInfo) GetElementType() TypeInfo { return c.ElementType } |
| func (c *StaticArrayInfo) GetSize() uint32 { return c.Size } |
| |
| func CreateMapInfo( |
| Name string, |
| Kind TypeKind, |
| KeyType TypeInfo, |
| ValueType TypeInfo, |
| ) *MapInfo { |
| return &MapInfo{ |
| Name: Name, |
| Kind: Kind, |
| KeyType: KeyType, |
| ValueType: ValueType, |
| } |
| } |
| |
| func (c *MapInfo) GetName() string { return c.Name } |
| func (c *MapInfo) GetKind() TypeKind { return c.Kind } |
| func (c *MapInfo) GetKeyType() TypeInfo { return c.KeyType } |
| func (c *MapInfo) GetValueType() TypeInfo { return c.ValueType } |
| |
| func CreateEnumInfo( |
| Name string, |
| Kind TypeKind, |
| Entries EnumEntryArray, |
| Extends EnumInfoPtrArray, |
| ) *EnumInfo { |
| return &EnumInfo{ |
| Name: Name, |
| Kind: Kind, |
| Entries: Entries, |
| Extends: Extends, |
| } |
| } |
| |
| func (c *EnumInfo) GetName() string { return c.Name } |
| func (c *EnumInfo) GetKind() TypeKind { return c.Kind } |
| func (c *EnumInfo) GetEntries() EnumEntryArray { return c.Entries } |
| func (c *EnumInfo) GetExtends() EnumInfoPtrArray { return c.Extends } |
| |
| func CreateEnumEntry( |
| Name string, |
| Value uint32, |
| ) *EnumEntry { |
| return &EnumEntry{ |
| Name: Name, |
| Value: Value, |
| } |
| } |
| |
| func (c *EnumEntry) GetName() string { return c.Name } |
| func (c *EnumEntry) GetValue() uint32 { return c.Value } |
| |
| func CreateStructInfo( |
| Name string, |
| Kind TypeKind, |
| Fields FieldInfoPtrArray, |
| ) *StructInfo { |
| return &StructInfo{ |
| Name: Name, |
| Kind: Kind, |
| Fields: Fields, |
| } |
| } |
| |
| func (c *StructInfo) GetName() string { return c.Name } |
| func (c *StructInfo) GetKind() TypeKind { return c.Kind } |
| func (c *StructInfo) GetFields() FieldInfoPtrArray { return c.Fields } |
| |
| func CreateClassInfo( |
| Name string, |
| Kind TypeKind, |
| Fields FieldInfoPtrArray, |
| Extends ClassInfoPtrArray, |
| ) *ClassInfo { |
| return &ClassInfo{ |
| Name: Name, |
| Kind: Kind, |
| Fields: Fields, |
| Extends: Extends, |
| } |
| } |
| |
| func (c *ClassInfo) GetName() string { return c.Name } |
| func (c *ClassInfo) GetKind() TypeKind { return c.Kind } |
| func (c *ClassInfo) GetFields() FieldInfoPtrArray { return c.Fields } |
| func (c *ClassInfo) GetExtends() ClassInfoPtrArray { return c.Extends } |
| |
| func CreateFieldInfo( |
| Name string, |
| Type TypeInfo, |
| ) *FieldInfo { |
| return &FieldInfo{ |
| Name: Name, |
| Type: Type, |
| } |
| } |
| |
| func (c *FieldInfo) GetName() string { return c.Name } |
| func (c *FieldInfo) GetType() TypeInfo { return c.Type } |
| |
| func CreateAtomInfo( |
| Api ApiId, |
| Type uint16, |
| Name string, |
| Parameters ParameterInfoArray, |
| IsCommand bool, |
| IsDrawCall bool, |
| IsEndOfFrame bool, |
| DocumentationUrl string, |
| ) *AtomInfo { |
| return &AtomInfo{ |
| Api: Api, |
| Type: Type, |
| Name: Name, |
| Parameters: Parameters, |
| IsCommand: IsCommand, |
| IsDrawCall: IsDrawCall, |
| IsEndOfFrame: IsEndOfFrame, |
| DocumentationUrl: DocumentationUrl, |
| } |
| } |
| |
| func (c *AtomInfo) GetApi() ApiId { return c.Api } |
| func (c *AtomInfo) GetType() uint16 { return c.Type } |
| func (c *AtomInfo) GetName() string { return c.Name } |
| func (c *AtomInfo) GetParameters() ParameterInfoArray { return c.Parameters } |
| func (c *AtomInfo) GetIsCommand() bool { return c.IsCommand } |
| func (c *AtomInfo) GetIsDrawCall() bool { return c.IsDrawCall } |
| func (c *AtomInfo) GetIsEndOfFrame() bool { return c.IsEndOfFrame } |
| func (c *AtomInfo) GetDocumentationUrl() string { return c.DocumentationUrl } |
| |
| func CreateParameterInfo( |
| Name string, |
| Type TypeInfo, |
| Out bool, |
| ) *ParameterInfo { |
| return &ParameterInfo{ |
| Name: Name, |
| Type: Type, |
| Out: Out, |
| } |
| } |
| |
| func (c *ParameterInfo) GetName() string { return c.Name } |
| func (c *ParameterInfo) GetType() TypeInfo { return c.Type } |
| func (c *ParameterInfo) GetOut() bool { return c.Out } |
| |
| func CreateSimpleInfo( |
| Name string, |
| Kind TypeKind, |
| ) *SimpleInfo { |
| return &SimpleInfo{ |
| Name: Name, |
| Kind: Kind, |
| } |
| } |
| |
| func (c *SimpleInfo) GetName() string { return c.Name } |
| func (c *SimpleInfo) GetKind() TypeKind { return c.Kind } |