087b7e7abf
This code was not tested and breaks in Release builds, reverting to restore
functionality of the nightly. All in-game menus do not work and generating
a world crashes.
This reverts commit a9be52c41a.
958 lines
33 KiB
C++
958 lines
33 KiB
C++
/********************************************************
|
|
* *
|
|
* Copyright (C) Microsoft. All rights reserved. *
|
|
* *
|
|
********************************************************/
|
|
|
|
// Sentient Client UGC API
|
|
//
|
|
// Include this to get access to all UGC related Sentient features
|
|
|
|
#pragma once
|
|
|
|
// Local headers
|
|
#include "SenClientMarkers.h"
|
|
#include "SenClientUGCLeaderboards.h"
|
|
#include "SenClientUGCTypes.h"
|
|
|
|
// Sentient headers
|
|
#include "SenClientSys.h"
|
|
#include "SenClientCulture.h"
|
|
|
|
namespace Sentient
|
|
{
|
|
/**********************************
|
|
***** UGC Creation Functions *****
|
|
**********************************/
|
|
|
|
/// @brief Generate a unique ID that will be used to
|
|
/// identify a given instance of UGC. This ID
|
|
/// will is referenced by every other UGC function.
|
|
///
|
|
/// @param[in] userIndex
|
|
/// The index of the initiating user on the console.
|
|
/// Note: This is NOT a XUID.
|
|
///
|
|
/// @param[out] outResult
|
|
/// The unique ID that has been generated and provisioned
|
|
/// for an instance of UGC.
|
|
///
|
|
/// @param[in] userCallback
|
|
/// If this call returns a success code,
|
|
/// the userCallback will be called at the end of the
|
|
/// asynchronous process.
|
|
///
|
|
/// @param[in] userCallbackData
|
|
/// Data to be passed to the @a userCallback on completion.
|
|
///
|
|
/// @return TBD
|
|
///
|
|
/// @details All UGC functions require a uniquely provisioned UGC ID.
|
|
///
|
|
/// @related All UGC related functions.
|
|
HRESULT SenUGCCreatePublishingUGCID(
|
|
int userIndex,
|
|
SenUGCID *outResult,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
///
|
|
/// @brief Async output information for SenUGCUpload or Download callers
|
|
///
|
|
/// @details Contains progress or retry information in addition to a cancellation token
|
|
///
|
|
struct SenUGCProgressInfo
|
|
{
|
|
SenHandle out_taskHandle; /// token for canceling the upload process
|
|
INT8 percentageComplete; /// 1-100, how much percent is complete of upload process for blob
|
|
size_t bytesCompleted; /// how many bytes have been successfully transmitted for the task
|
|
HRESULT lastStepResult; /// sentient client SDK HRESULT value
|
|
int numRetries; /// does not reset between internal steps for a long-running task
|
|
};
|
|
|
|
//************************************
|
|
// Method: SenUGCUpload
|
|
// FullName: Sentient::SenUGCUpload
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenUGCID ugcID
|
|
// Parameter: const SenUGCMetaData * metaData
|
|
// Parameter: int nrMainDataBlobs
|
|
// Parameter: const void * * mainDataBlobs
|
|
// Parameter: const size_t * mainDataBlobSizes
|
|
// Parameter: bool pushToFeed
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Upload the metadata, as well as one or more binary data blobs to the server.
|
|
// There are multiple data blobs supported (the exact number is defined in
|
|
// SenUGCMainData_NrBlobs). One use would be that a game may want store a
|
|
// preview thumbnail that can be downloaded without having to download the
|
|
// rest of the UGC. This could save bandwidth and make the game more responsive.
|
|
// Note: data blob 0 should be the main level data blob, for the automatic
|
|
// download counter to work.
|
|
// The metadata will also have a data blob associated, but this should be
|
|
// kept to a minimum, as UGC download menus will probably want to download
|
|
// metadata for a lot of UGCs at once.
|
|
// Note: if a level has been uploaded with main data before, and the creator
|
|
// wants to just modify the metadata, they can upload the metadata with the
|
|
// maindatablobs being NULL.
|
|
// NOTE: for large items, use the SenUGCUploadMainData method with the SenUGCProgressInfo
|
|
// signature so you can get the running progress and a cancellation token
|
|
// to abort the upload (allowing UI for the user, etc)
|
|
//************************************
|
|
HRESULT SenUGCUpload(
|
|
int userIndex,
|
|
SenUGCID ugcID,
|
|
const SenUGCMetaData *metaData,
|
|
int nrMainDataBlobs,
|
|
const void **mainDataBlobs,
|
|
const size_t *mainDataBlobSizes,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
//************************************
|
|
// Method: SenUGCUploadMetadata
|
|
// FullName: Sentient::SenUGCUploadMetadata
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenUGCID ugcID
|
|
// Parameter: const SenUGCMetaData * metaData
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Upload the metadata and one binary data blob to the server.
|
|
// NOTE: data blob at index 0 should be the main level data blob, for the automatic
|
|
// download counter to work.
|
|
// The metadata will also have a data blob associated, but this should be
|
|
// kept to a minimum, as UGC download menus will probably want to download
|
|
// metadata for a lot of UGCs at once.
|
|
// NOTE: If a creator uploads metadata again, it will overwrite the previous
|
|
// stored blob with the new one.
|
|
//************************************
|
|
HRESULT SenUGCUploadMetadata(
|
|
int userIndex,
|
|
SenUGCID ugcID,
|
|
const SenUGCMetaData* metaData,
|
|
SenSysCompletedCallback userCallback,
|
|
void* userCallbackData);
|
|
|
|
//************************************
|
|
// Method: SenUGCUploadMainData
|
|
// FullName: Sentient::SenUGCUploadMainData
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenUGCID ugcID
|
|
// Parameter: int mainDataBlobIndex
|
|
// Parameter: const void * mainDataBlob
|
|
// Parameter: const size_t mainDataBlobSize
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Parameter: SenUGCProcessInfo* out_ugcUploadInfo
|
|
// Upload one binary data blob to the server.
|
|
// This SenUGCUpload method with the SenUGCProcessInfo signature is so you
|
|
// can get the progress percentage and a cancellation token, which can
|
|
// be used to abort the upload. This is useful for large uploads where
|
|
// you may want to allow the user to cancel.
|
|
// NOTE: This call is asynchronous ONLY and will error for synchronous
|
|
// attempts with a NULL param for userCallback.
|
|
// There are multiple data blobs supported (the exact number is defined in
|
|
// SenUGCMainData_NrBlobs) on subsequent calls. Slot zero is to be used by a
|
|
// game to store a preview thumbnail, which can then be downloaded without
|
|
// having to download the rest of the UGC. This could save bandwidth and
|
|
// make the game more responsive.
|
|
// NOTE: data blob at index 0 should be the main level data blob, for the automatic
|
|
// download counter to work.
|
|
// The metadata will also have a data blob associated, but this should be
|
|
// kept to a minimum, as UGC download menus will probably want to download
|
|
// metadata for a lot of UGCs at once.
|
|
// NOTE: if a level has been uploaded with main data before, and the creator
|
|
// wants to just modify the metadata, they can upload the metadata with the
|
|
// main data blob being NULL.
|
|
// NOTE: If a creator uploads a data blob again, it will overwrite the previous
|
|
// stored blob with the new one.
|
|
//************************************
|
|
HRESULT SenUGCUploadMainDataBlob(
|
|
int userIndex,
|
|
SenUGCID ugcID,
|
|
int mainDataBlobIndex,
|
|
const void* mainDataBlob,
|
|
const size_t mainDataBlobSize,
|
|
SenSysCompletedCallback userCallback,
|
|
void* userCallbackData,
|
|
SenUGCProgressInfo* out_progressInfo);
|
|
|
|
//************************************
|
|
// Method: SenUGCDelete
|
|
// FullName: Sentient::SenUGCDelete
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenUGCID ugcID
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Delete the UGC - only the user that created the UGC can delete it.
|
|
//************************************
|
|
HRESULT SenUGCDelete(
|
|
int userIndex,
|
|
SenUGCID ugcID,
|
|
SenSysCompletedCallback userCallback,
|
|
void* userCallbackData );
|
|
|
|
/*************************************
|
|
***** UGC Consumption Functions *****
|
|
*************************************/
|
|
|
|
//************************************
|
|
// Method: SenUGCEnumerate
|
|
// FullName: Sentient::SenUGCEnumerate
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenSysTitleID titleID
|
|
// Parameter: SenUGCSortBy sortBy
|
|
// Parameter: SenUGCType type
|
|
// Parameter: SenUGCAuthorType authorType
|
|
// Parameter: int nrAuthors
|
|
// Parameter: const XUID * authorList
|
|
// Parameter: SenUGCMetaDataFlags metaDataFlagFilter
|
|
// Parameter: SenUGCPublishState minPublishStateFilter
|
|
// Parameter: SenUGCPublishState maxPublishStateFilter
|
|
// Parameter: SenSysDateTime newerThan
|
|
// Parameter: SenUGCDescriptor descriptor
|
|
// Parameter: int maxNrResults
|
|
// Parameter: SenUGCSearchResult * outBuffer
|
|
// Parameter: unsigned int * outNrResults
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Search the database for all the UGCs that match various search criteria.
|
|
// outBuffer should be an preallocated array of [sizeof(SenUGCSearchResult)*maxNrResults] bytes.
|
|
//************************************
|
|
HRESULT SenUGCEnumerate(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCSortBy sortBy,
|
|
SenUGCType type,
|
|
SenUGCAuthorType authorType,
|
|
int nrAuthors,
|
|
const PlayerUID *authorList,
|
|
SenUGCMetaDataFlags metaDataFlagFilter,
|
|
SYSTEMTIME *newerThan,
|
|
SenUGCDescriptor descriptor,
|
|
int maxNrResults,
|
|
SenUGCSearchResult *outBuffer,
|
|
UINT *outNrResults,
|
|
SenSysCompletedCallback userCallback,
|
|
void* userCallbackData );
|
|
|
|
|
|
/// @brief public
|
|
///
|
|
/// @param[in] userIndex
|
|
/// @param[in] titleID
|
|
/// @param[in] sortBy
|
|
/// @param[in] type
|
|
/// @param[in] authorType
|
|
/// @param[in] nrAuthors
|
|
/// @param[in] authorList
|
|
/// @param[in] metaDataFlagFilter
|
|
/// @param[in] newerThan
|
|
/// @param[in] nrDescriptors
|
|
/// @param[in] descriptors
|
|
/// @param[in] maxNrResults
|
|
/// @param[out] outBuffer
|
|
/// @param[out] outNrResults
|
|
/// @param[in] userCallback
|
|
/// @param[in] userCallbackData
|
|
///
|
|
/// @return Search the database for all the UGCs that match various search criteria.
|
|
/// outBuffer should be an preallocated array of [sizeof(SenUGCSearchResult)*maxNrResults] bytes.
|
|
///
|
|
/// @details Enumerate by name will perform a look based on a various search criteria. The Collection
|
|
/// of descriptors will perform an equality lookup on Descriptor
|
|
///
|
|
/// @related SenUGCEnumerate
|
|
HRESULT SenUGCEnumerate(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCSortBy sortBy,
|
|
SenUGCType type,
|
|
SenUGCAuthorType authorType,
|
|
int nrAuthors,
|
|
const PlayerUID *authorList,
|
|
SenUGCMetaDataFlags metaDataFlagFilter,
|
|
SYSTEMTIME *newerThan,
|
|
int nrDescriptors,
|
|
INT64 *descriptors,
|
|
int maxNrResults,
|
|
SenUGCSearchResult *outBuffer,
|
|
UINT *outNrResults,
|
|
SenSysCompletedCallback userCallback,
|
|
void* userCallbackData );
|
|
|
|
/// @brief public
|
|
///
|
|
/// @param[in] userIndex
|
|
/// @param[in] titleID
|
|
/// @param[in] sortBy
|
|
/// @param[in] type
|
|
/// @param[in] authorType
|
|
/// @param[in] nrAuthors
|
|
/// @param[in] authorList
|
|
/// @param[in] metaDataFlagFilter
|
|
/// @param[in] newerThan
|
|
/// @param[in] nrDescriptors
|
|
/// @param[in] descriptors
|
|
/// @param[in] maxNrResults
|
|
/// @param[out] outBuffer
|
|
/// @param[out] outNrResults
|
|
/// @param[in] userCallback
|
|
/// @param[in] userCallbackData
|
|
///
|
|
/// @return Search the database for all the UGCs that match various search criteria.
|
|
/// outBuffer should be an preallocated array of [sizeof(SenUGCSearchResult)*maxNrResults] bytes.
|
|
///
|
|
/// @details Enumerate by Descriptor using a Logical And against all submitted Descriptor values.
|
|
/// The API filters the results on a specific UGC Type as well as an author
|
|
/// list type. Author List type of Everyone is NOT supported.
|
|
/// Note: The collection of descriptor bit masks is constrained to four.
|
|
///
|
|
/// @related SenUGCEnumerate
|
|
HRESULT SenUGCEnumerateByDescriptorWithLogicalAnd(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCSortBy sortBy,
|
|
SenUGCType type,
|
|
SenUGCAuthorType authorType,
|
|
int nrAuthors,
|
|
const PlayerUID *authorList,
|
|
SenUGCMetaDataFlags metaDataFlagFilter,
|
|
SYSTEMTIME *newerThan,
|
|
int nrDescriptors,
|
|
INT64 *descriptors,
|
|
int maxNrResults,
|
|
SenUGCSearchResult *outBuffer,
|
|
UINT *outNrResults,
|
|
SenSysCompletedCallback userCallback,
|
|
void* userCallbackData );
|
|
|
|
/// @brief public
|
|
///
|
|
/// @param[in] userIndex
|
|
/// @param[in] titleID
|
|
/// @param[in] type
|
|
/// @param[in] authorType
|
|
/// @param[in] nrAuthors
|
|
/// @param[in] authorList
|
|
/// @param[in] name
|
|
/// @param[in] maxNrResults
|
|
/// @param[out] outBuffer
|
|
/// @param[out] outNrResults
|
|
/// @param[in] userCallback
|
|
/// @param[in] userCallbackData
|
|
///
|
|
/// @return Search the database for all the UGCs that match various search criteria.
|
|
/// outBuffer should be an preallocated array of [sizeof(SenUGCSearchResult)*maxNrResults] bytes.
|
|
///
|
|
/// @details Enumerate by name will perform a wild card lookup on UGC name. The lookup will return anything
|
|
/// in the range of "%<NAME>%". The API filters the results on a specific UGC Type as well as an author
|
|
/// list type. Author List type of Everyone is NOT supported.
|
|
///
|
|
/// @related SenUGCEnumerate
|
|
__declspec(deprecated("Use SenUGCEnumerateByName() instead"))
|
|
HRESULT SenUGCEnumerate(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCType type,
|
|
SenUGCAuthorType authorType,
|
|
int nrAuthors,
|
|
const PlayerUID *authorList,
|
|
const wchar_t *name,
|
|
int maxNrResults,
|
|
SenUGCSearchResult *outBuffer,
|
|
UINT *outNrResults,
|
|
SenSysCompletedCallback userCallback,
|
|
void* userCallbackData );
|
|
|
|
/// @brief public
|
|
///
|
|
/// @param[in] userIndex
|
|
/// @param[in] titleID
|
|
/// @param[in] type
|
|
/// @param[in] authorType
|
|
/// @param[in] nrAuthors
|
|
/// @param[in] authorList
|
|
/// @param[in] name
|
|
/// @param[in] performWildCardLookup
|
|
/// @param[in] maxNrResults
|
|
/// @param[out] outBuffer
|
|
/// @param[out] outNrResults
|
|
/// @param[in] userCallback
|
|
/// @param[in] userCallbackData
|
|
///
|
|
/// @return Search the database for all the UGCs that match various search criteria.
|
|
/// outBuffer should be an preallocated array of [sizeof(SenUGCSearchResult)*maxNrResults] bytes.
|
|
///
|
|
/// @details Enumerate by name will perform an exact or wild card string lookup on UGC name. The API filters the results
|
|
/// on a specific UGC Type as well as an author list type. Author List type of Everyone is NOT supported.
|
|
///
|
|
/// @related SenUGCEnumerate
|
|
HRESULT SenUGCEnumerateByName(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCType type,
|
|
SenUGCAuthorType authorType,
|
|
int nrAuthors,
|
|
const PlayerUID *authorList,
|
|
const wchar_t *name,
|
|
bool performWildCardLookup,
|
|
int maxNrResults,
|
|
SenUGCSearchResult *outBuffer,
|
|
UINT *outNrResults,
|
|
SenSysCompletedCallback userCallback,
|
|
void* userCallbackData );
|
|
|
|
//************************************
|
|
// Method: SenUGCDownloadMetaData
|
|
// FullName: Sentient::SenUGCDownloadMetaData
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenSysTitleID titleID
|
|
// Parameter: int nrUGCs
|
|
// Parameter: const SenUGCID * ugcIDList
|
|
// Parameter: SenUGCDownloadedMetaData2 * outBuffer
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Download the metadata for an array of UGCs
|
|
// Note that the metadata structure is a superset of the uploaded metadata,
|
|
// with various other information exposed.
|
|
// outBuffer should be an preallocated array of [(sizeof(SenUGCDownloadedMetaData)+SenUGCMetaData::BlobSizeLimit)*nrUGCs] bytes.
|
|
// This new signature is compatible with resubmission feature and 64-bit UGC Ids.
|
|
//************************************
|
|
HRESULT SenUGCDownloadMetaData(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
int nrUGCs,
|
|
const SenUGCID *ugcIDList,
|
|
SenUGCDownloadedMetaData2 *out_metaData,
|
|
size_t *out_metaDataCount,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
__declspec(deprecated("Use signature with SenUGCDownloadedMetaData2."))
|
|
HRESULT SenUGCDownloadMetaData(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
int nrUGCs,
|
|
const SenUGCID *ugcIDList,
|
|
SenUGCDownloadedMetaData *out_metaData,
|
|
size_t *out_metaDataCount,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
//************************************
|
|
// Method: SenUGCDownloadMainDataBlob
|
|
// FullName: Sentient::SenUGCDownloadMainDataBlob
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenUGCID ugcID
|
|
// Parameter: int mainDataBlobID
|
|
// Parameter: size_t bufferSize
|
|
// Parameter: UINT blobVersion
|
|
// Parameter: void * outBuffer
|
|
// Parameter: size_t * outSize
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Download a single blob of UGC data
|
|
// note that zero byte downloads will fail.
|
|
// ID, blobVersion, and bufferSize should be coming
|
|
// from SenUGCDownloadedMetaData.
|
|
// outBuffer should be an preallocated array of bufferSize bytes.
|
|
//************************************
|
|
HRESULT SenUGCDownloadMainDataBlob(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCID ugcID,
|
|
UINT mainDataBlobIndex,
|
|
size_t bufferSize,
|
|
UINT blobVersion,
|
|
void *outBuffer,
|
|
size_t *outSize,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
__declspec(deprecated("Use signature with blobVersion."))
|
|
HRESULT SenUGCDownloadMainDataBlob(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCID ugcID,
|
|
int mainDataBlobIndex,
|
|
size_t bufferSize,
|
|
void *outBuffer,
|
|
size_t *outBytesReceived,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
//************************************
|
|
// Method: SenUGCDownloadMainDataBlob
|
|
// FullName: Sentient::SenUGCDownloadMainDataBlob
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenUGCID ugcID
|
|
// Parameter: int mainDataBlobID
|
|
// Parameter: size_t bufferSize
|
|
// Parameter: UINT blobVersion
|
|
// Parameter: void * outBuffer
|
|
// Parameter: size_t * outBytesReceived
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Download a single blob of UGC data
|
|
// NOTE: zero byte downloads will fail.
|
|
// ID, mainDataRevision and bufferSize should be coming from a
|
|
// SenUGCDownloadedMetaData2 (where bufferSize comes from
|
|
// SenUGCDownloadedMetaData2's BlobInfo[mainDataBlobID].Size).
|
|
// outBuffer should be an preallocated array of bufferSize bytes.
|
|
// This signature includes an out param to include the progress
|
|
// percentage and cancellation token, etc to monitor and abort
|
|
// long running downloads (can be wired up to UI for users).
|
|
// BlobVersion is the version of the blob you want to download,
|
|
// which is available on the metadata information for the
|
|
// main data blobs (via DownloadMetaData).
|
|
//************************************
|
|
HRESULT SenUGCDownloadMainDataBlob(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCID ugcID,
|
|
UINT mainDataBlobIndex,
|
|
size_t bufferSize,
|
|
UINT blobVersion,
|
|
void *outBuffer,
|
|
size_t *outBytesReceived,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData,
|
|
SenUGCProgressInfo* out_progressInfo);
|
|
|
|
__declspec(deprecated("Use signature with blobVersion."))
|
|
HRESULT SenUGCDownloadMainDataBlob(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCID ugcID,
|
|
int mainDataBlobIndex,
|
|
size_t bufferSize,
|
|
void *outBuffer,
|
|
size_t *outBytesReceived,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData,
|
|
SenUGCProgressInfo* out_progressInfo);
|
|
|
|
/**********************************************
|
|
***** UGC Reviewing and Rating Functions *****
|
|
**********************************************/
|
|
|
|
//************************************
|
|
// Method: SenUGCSetReviewScore
|
|
// FullName: Sentient::SenUGCSetReviewScore
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenUGCID ugcId
|
|
// Parameter: SenUGCReviewScoreType type
|
|
// Parameter: UINT score
|
|
// Parameter: bool isFavorite
|
|
// Parameter: SenSysCompletedCallback callback
|
|
// Parameter: void * callbackData
|
|
//************************************
|
|
HRESULT SenUGCSetReviewScore(
|
|
int userIndex,
|
|
SenUGCID ugcId,
|
|
SenUGCReviewScoreType type,
|
|
unsigned int score,
|
|
bool isFavorite,
|
|
SenSysCompletedCallback callback,
|
|
void *callbackData );
|
|
|
|
//************************************
|
|
// Method: SenUGCGetReviewScore
|
|
// FullName: Sentient::SenUGCGetReviewScore
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenUGCID ugcId
|
|
// Parameter: SenUGCReviewScoreType type
|
|
// Parameter: UINT * out_score
|
|
// Parameter: SenSysCompletedCallback callback
|
|
// Parameter: void * callbackData
|
|
//************************************
|
|
HRESULT SenUGCGetReviewScore(
|
|
int userIndex,
|
|
SenUGCID ugcId,
|
|
SenUGCReviewScoreType type,
|
|
unsigned int *out_score,
|
|
SenSysCompletedCallback callback,
|
|
void *callbackData );
|
|
|
|
//************************************
|
|
// Method: SenUGCSetFavoriteFlag
|
|
// FullName: Sentient::SenUGCSetFavoriteFlag
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenSysTitleID titleID
|
|
// Parameter: SenUGCID ugcID
|
|
// Parameter: bool isFavorite
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Users can flag the UGCs that they really like, which can be used for
|
|
// the search results
|
|
//************************************
|
|
HRESULT SenUGCSetFavoriteFlag(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCID ugcID,
|
|
BOOL isFavorite,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
//************************************
|
|
// Method: SenUGCGetFavoriteFlag
|
|
// FullName: Sentient::SenUGCGetFavoriteFlag
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenSysTitleID titleID
|
|
// Parameter: SenUGCID ugcID
|
|
// Parameter: BOOL * outResult
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Users can flag the UGCs that they really like, which can be used for
|
|
// the search results
|
|
//************************************
|
|
HRESULT SenUGCGetFavoriteFlag(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCID ugcID,
|
|
BOOL *outResult,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
//************************************
|
|
// Method: SenUGCGetFriendFavoriteCount
|
|
// FullName: Sentient::SenUGCGetFriendFavoriteCount
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenSysTitleID titleID
|
|
// Parameter: SenUGCID ugcID
|
|
// Parameter: int * outResult
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Find out how many friends of the user have flagged this UGC as
|
|
// a favorite (inclusive the user's favorite flag also)
|
|
//************************************
|
|
HRESULT SenUGCGetFriendFavoriteCount(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCID ugcID,
|
|
int *outResult,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
//************************************
|
|
// Method: SenUGCAddToCustomCounters
|
|
// FullName: Sentient::SenUGCAddToCustomCounters
|
|
// Access: public
|
|
// Returns: HRESULT
|
|
// Qualifier:
|
|
// Parameter: int userIndex
|
|
// Parameter: SenSysTitleID titleID
|
|
// Parameter: SenUGCID ugcID
|
|
// Parameter: INT64 customCounters[SenUGCDownloadedMetaData_NrCustomCounters]
|
|
// Parameter: SenSysCompletedCallback userCallback
|
|
// Parameter: void * userCallbackData
|
|
// Users can add to a fixed number of global counters stored on the
|
|
// servers, to count up a few basic stats per UGC (number of deaths,
|
|
// number of enemies killed, total playtime etc.)
|
|
//************************************
|
|
HRESULT SenUGCAddToCustomCounters(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCID ugcID,
|
|
INT64 customCounters[SenUGCDownloadedMetaData_NrCustomCounters],
|
|
SenSysCompletedCallback userCallback,
|
|
void* userCallbackData );
|
|
|
|
/// @brief API to flag a given piece of UGC as offensive.
|
|
///
|
|
/// @param[in] userIndex
|
|
/// The index of the initiating user on the console.
|
|
/// Note: This is NOT a XUID.
|
|
///
|
|
/// @param[in] ugcID
|
|
/// The unique ID for an instance of UGC.
|
|
///
|
|
/// @param[in] offensivenessFlag
|
|
/// Offensive flag type.
|
|
///
|
|
/// @param[in] reason
|
|
/// Reason for marking a given piece of UGC as offensive.
|
|
///
|
|
/// @param[in] userCallback
|
|
/// If this call returns a success code,
|
|
/// the userCallback will be called at the end of the
|
|
/// asynchronous process.
|
|
///
|
|
/// @param[in] userCallbackData
|
|
/// Data to be passed to the @a userCallback on completion.
|
|
///
|
|
/// @return Check SUCCEEDED( hresult ) or FAILED( hresult ) to determine success.
|
|
/// Specific values include:
|
|
///
|
|
/// @details Users can flag a level that they think is offensive. The goal is that
|
|
/// the Sentient system will automatically be able to take down
|
|
/// levels after enough people have flagged a UGC as bad.
|
|
/// The number of votes to take something down will depend on the
|
|
/// reliability of the reviewers (number of offensiveness flags vs number of
|
|
/// downloads etc.) as well as the number of offensive uploads by the creator.
|
|
/// This function is also used by moderators to confirm or deny something as
|
|
/// being offensive.
|
|
///
|
|
/// @related <Related API>
|
|
HRESULT SenUGCSetOffensivenessFlag(
|
|
int userIndex,
|
|
SenUGCID ugcID,
|
|
SenUGCOffensivenessFlag offensivenessFlag,
|
|
const wchar_t *reason,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
/// @brief This function will return whether or not a particular
|
|
/// piece of UGC has been banned.
|
|
///
|
|
/// @param[in] userIndex
|
|
/// The index of the initiating user on the console.
|
|
/// Note: This is NOT a XUID.
|
|
///
|
|
/// @param[in] The unique ID for UGC.
|
|
///
|
|
/// @param[in] True if content is banned (and should not be viewed by user).
|
|
///
|
|
/// @param[in] userCallback
|
|
/// If this call returns a success code,
|
|
/// the userCallback will be called at the end of the
|
|
/// asynchronous process.
|
|
///
|
|
/// @param[in] userCallbackData
|
|
/// Data to be passed to the @a userCallback on completion.
|
|
///
|
|
/// @return Check SUCCEEDED( hresult ) or FAILED( hresult ) to determine success.
|
|
/// Specific values include:
|
|
///
|
|
/// @details Any piece of UGC can been banned by a moderator or
|
|
/// moderation engine. This API allows clients to verify
|
|
/// if a given piece of UGC has been banned.
|
|
///
|
|
/// @related SenUGCCreatePublishingUGCID()
|
|
/// @related SenUGCSetOffensivenessFlag()
|
|
/// @related SenUGCPublish()
|
|
HRESULT SenUGCIsBanned(
|
|
int userIndex,
|
|
SenUGCID ugcID,
|
|
BOOL *out_result,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
/*********************
|
|
***** UGC Feeds *****
|
|
*********************/
|
|
|
|
/// @brief UGC Feed information
|
|
///
|
|
/// @details When enumerating feeds, these are the available feeds that can be retrieved.
|
|
///
|
|
struct SenUGCFeedInfo
|
|
{
|
|
SenUGCFeedType feedType;
|
|
wchar_t Name[32];
|
|
wchar_t Description[128];
|
|
};
|
|
|
|
/// @brief Retrieves a specific feed based on feedtype.
|
|
///
|
|
/// @param[in] userIndex
|
|
/// The index of the initiating user on the console.
|
|
/// Note: This is NOT a XUID.
|
|
///`
|
|
/// @param[in] titleID
|
|
///
|
|
/// @param[in] feedType
|
|
/// Feed Type identifier for for the given feed being retrieved.
|
|
///
|
|
/// @param[in] maxNumberOfFeedItems
|
|
/// Used to indicate the number of items to be returned by @a out_feedInfo.
|
|
/// If the actual number of items exceeds this, you will receive an error.
|
|
///
|
|
/// @param[out] out_buffer
|
|
/// Pointer to the collection of structures to fill with SenUGCFeedItem data.
|
|
///
|
|
/// @param[out] out_buffersize
|
|
/// The number of entries actually enumerated by the call.
|
|
///
|
|
/// @param[in] userCallback
|
|
/// If this call returns a success code,
|
|
/// the userCallback will be called at the end of the
|
|
/// asynchronous process.
|
|
///
|
|
/// @param[in] userCallbackData
|
|
/// Data to be passed to the @a userCallback on completion.
|
|
///
|
|
/// @return Check SUCCEEDED( hresult ) or FAILED( hresult ) to determine success.
|
|
/// Specific values include:
|
|
/// E_POINTER: out_buffer or out_buffersize are null.
|
|
///
|
|
/// @details <Insert detailed method documentation>
|
|
///
|
|
/// @related SenUGCEnumerateFeeds()
|
|
HRESULT SenUGCGetFeed(
|
|
int userIndex,
|
|
SenSysTitleID titleID,
|
|
SenUGCFeedType feedType,
|
|
size_t maxNumberOfFeedItems,
|
|
SenUGCFeedItem *out_buffer,
|
|
UINT *out_buffersize,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData );
|
|
|
|
/// @brief Retrieves a collection of feeds that are viewable by the
|
|
/// current user.
|
|
///
|
|
/// @param[in] userIndex
|
|
/// The index of the initiating user on the console.
|
|
/// Note: This is NOT a XUID.
|
|
///
|
|
/// @param[in] culture
|
|
/// This is the result of a call to SenCultureFind() or SenCultureGet*().
|
|
/// You may also pass NULL to use the culture set with SenCultureSetCurrent().
|
|
/// May be NULL for default culture.
|
|
///
|
|
/// @param[in] maxResults
|
|
/// Used to indicate the number of items to be returned by @a out_feedInfo.
|
|
/// If the actual number of items exceeds this, you will receive an error.
|
|
///
|
|
/// @param[out] out_feedInfo
|
|
/// Pointer to a collection of structures to fill with SenUGCFeedInfo data.
|
|
///
|
|
/// @param[out] out_resultCount
|
|
/// The number of entries actually enumerated by the call.
|
|
///
|
|
/// @param[in] userCallback
|
|
/// If this call returns a success code,
|
|
/// the userCallback will be called at the end of the
|
|
/// asynchronous process.
|
|
///
|
|
/// @param[in] userCallbackData
|
|
/// Data to be passed to the @a userCallback on completion.
|
|
///
|
|
/// @return Check SUCCEEDED( hresult ) or FAILED( hresult ) to determine success.
|
|
/// Specific values include:
|
|
/// E_POINTER: out_feedInfo or out_resultCount are null.
|
|
///
|
|
/// @details <Insert detailed method documentation>
|
|
///
|
|
/// @related SenUGCGetFeed()
|
|
HRESULT SenUGCEnumerateFeeds(
|
|
int userIndex,
|
|
size_t maxResults,
|
|
SenUGCFeedInfo *out_feedInfo,
|
|
size_t *out_resultCount,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData);
|
|
|
|
/// @brief API that publishes UGC and makes the content accessible
|
|
/// to everyone on the Sentient service.
|
|
///
|
|
/// @param[in] userIndex
|
|
/// The index of the initiating user on the console.
|
|
/// Note: This is NOT a XUID.
|
|
///
|
|
/// @param[in] ugcID
|
|
/// The unique ID for an instance of UGC.
|
|
///
|
|
/// @param[in] leaderboardDefinition
|
|
/// Optional parameter. Definition for a Leaderboard that
|
|
/// will be created and associated to newly published UGC.
|
|
///
|
|
/// @param[out] out_leaderboardId
|
|
/// Created Leaderboard Id. Only returned to the client if
|
|
/// a Leaderboards Definition is passed to the server.
|
|
///
|
|
/// @param[in] userCallback
|
|
/// If this call returns a success code,
|
|
/// the userCallback will be called at the end of the
|
|
/// asynchronous process.
|
|
///
|
|
/// @return Check SUCCEEDED( hresult ) or FAILED( hresult ) to determine success.
|
|
/// Specific values include:
|
|
///
|
|
/// @details UGC is only accessible to the author until it has been published.
|
|
/// The user making the call must be the author of the UGC item.
|
|
/// The call will fail if this UGC item has previously been published.
|
|
/// By supplying an optional Leaderboard definition a Leaderboard is automatically
|
|
// allocated and associated with the UGC item.
|
|
/// This is the preferred way of creating UGC Leaderboards.
|
|
///
|
|
/// @related SenCreateLeaderboard()
|
|
HRESULT SenUGCPublish(
|
|
int userIndex,
|
|
SenUGCID ugcID,
|
|
const SenLeaderboardDefinition *leaderboardDefinition,
|
|
SenLeaderboardId *out_leaderboardId,
|
|
SenSysCompletedCallback userCallback,
|
|
void *userCallbackData);
|
|
|
|
/// @brief API that publishes a new version of a UGC item and makes the revised content accessible
|
|
/// to everyone on the Sentient service.
|
|
///
|
|
/// @param[in] userIndex
|
|
/// The index of the initiating user on the console.
|
|
/// Note: This is NOT a XUID.
|
|
///
|
|
/// @param[in] ugcID
|
|
/// The unique ID for an instance of UGC.
|
|
///
|
|
/// @param[in] userCallback
|
|
/// If this call returns a success code,
|
|
/// the userCallback will be called at the end of the
|
|
/// asynchronous process.
|
|
///
|
|
/// @return Check SUCCEEDED( hresult ) or FAILED( hresult ) to determine success.
|
|
/// Specific values include:
|
|
///
|
|
/// @details New versions of UGC are only accessible to the author until it has been republished.
|
|
/// The user making the call must be the author of the UGC item.
|
|
///
|
|
/// @related SenUGCPublish()
|
|
HRESULT SenUGCRepublish(
|
|
int userIndex,
|
|
SenUGCID ugcID,
|
|
SenSysCompletedCallback userCallback,
|
|
void* userCallbackData);
|
|
|
|
} // namespace Sentient
|