u_int32_t
pmcCalcCrc_T02 (void *bufp)
{
FLD_TYPE2 *buf = bufp;
u_int32_t crc; /* CRC of the structure */
/* Calc CRC for type and length fields */
sbeCrc (
(u_int8_t *) &buf->type,
(u_int32_t) STRUCT_OFFSET (FLD_TYPE2, Crc32),
(u_int32_t) 0,
(u_int32_t *) &crc);
/* Calc CRC for remaining fields */
sbeCrc (
(u_int8_t *) &buf->Id[0],
(u_int32_t) (sizeof (FLD_TYPE2) - STRUCT_OFFSET (FLD_TYPE2, Id)),
(u_int32_t) crc,
(u_int32_t *) &crc);
#ifdef EEPROM_TYPE_DEBUG
pr_info("sbeCrc: crc 2 calculated as %08x\n", crc); /* RLD DEBUG */
#endif
return crc;
}
u_int32_t
pmcCalcCrc_T02 (void *bufp)
{
FLD_TYPE2 *buf = bufp;
u_int32_t crc; /* */
/* */
sbeCrc (
(u_int8_t *) &buf->type,
(u_int32_t) STRUCT_OFFSET (FLD_TYPE2, Crc32),
(u_int32_t) 0,
(u_int32_t *) &crc);
/* */
sbeCrc (
(u_int8_t *) &buf->Id[0],
(u_int32_t) (sizeof (FLD_TYPE2) - STRUCT_OFFSET (FLD_TYPE2, Id)),
(u_int32_t) crc,
(u_int32_t *) &crc);
#ifdef EEPROM_TYPE_DEBUG
pr_info("sbeCrc: crc 2 calculated as %08x\n", crc); /* */
#endif
return crc;
}
/** Initialization */
void Init(const FArrowVertexBuffer* VertexBuffer)
{
if (IsInRenderingThread())
{
// Initialize the vertex factory's stream components.
FDataType NewData;
NewData.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, Position, VET_Float3);
NewData.TextureCoordinates.Add(
FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FDynamicMeshVertex, TextureCoordinate), sizeof(FDynamicMeshVertex), VET_Float2)
);
NewData.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentX, VET_PackedNormal);
NewData.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentZ, VET_PackedNormal);
SetData(NewData);
}
else
{
ENQUEUE_UNIQUE_RENDER_COMMAND_TWOPARAMETER(
InitArrowVertexFactory,
FArrowVertexFactory*, VertexFactory, this,
const FArrowVertexBuffer*, VertexBuffer, VertexBuffer,
{
// Initialize the vertex factory's stream components.
FDataType NewData;
NewData.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, Position, VET_Float3);
NewData.TextureCoordinates.Add(
FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FDynamicMeshVertex, TextureCoordinate), sizeof(FDynamicMeshVertex), VET_Float2)
);
NewData.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentX, VET_PackedNormal);
NewData.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentZ, VET_PackedNormal);
VertexFactory->SetData(NewData);
});
}
void FSsPartsVertexFactory::Init(const FSsPartsVertexBuffer* VertexBuffer)
{
if(IsInRenderingThread())
{
FLocalVertexFactory::DataType Data;
Data.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, Position, VET_Float3);
Data.TextureCoordinates.Add(FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FSsPartVertex,TexCoord), sizeof(FSsPartVertex), VET_Float2));
Data.ColorComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, Color, VET_Color);
Data.TextureCoordinates.Add(FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FSsPartVertex,ColorBlend), sizeof(FSsPartVertex), VET_Float2));
Data.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, TangentX, VET_PackedNormal);
Data.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, TangentZ, VET_PackedNormal);
SetData(Data);
}
else
{
ENQUEUE_UNIQUE_RENDER_COMMAND_TWOPARAMETER(
FInitSsPartsVertexFactory,
FSsPartsVertexFactory*, VertexFactory, this,
const FSsPartsVertexBuffer*, VertexBuffer, VertexBuffer,
{
DataType Data;
Data.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, Position, VET_Float3);
Data.TextureCoordinates.Add(FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FSsPartVertex,TexCoord), sizeof(FSsPartVertex), VET_Float2));
Data.ColorComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, Color, VET_Color);
Data.TextureCoordinates.Add(FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FSsPartVertex,ColorBlend), sizeof(FSsPartVertex), VET_Float2));
Data.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, TangentX, VET_PackedNormal);
Data.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, TangentZ, VET_PackedNormal);
VertexFactory->SetData(Data);
});
}
void FLandscapeComponentSceneProxyMobile::CreateRenderThreadResources()
{
// Use only Index buffers
SharedBuffers = FLandscapeComponentSceneProxy::SharedBuffersMap.FindRef(SharedBuffersKey);
if (SharedBuffers == nullptr)
{
SharedBuffers = new FLandscapeSharedBuffers(
SharedBuffersKey, SubsectionSizeQuads, NumSubsections,
GetScene().GetFeatureLevel(), false);
FLandscapeComponentSceneProxy::SharedBuffersMap.Add(SharedBuffersKey, SharedBuffers);
}
SharedBuffers->AddRef();
int32 VertexBufferSize = PlatformData.Num();
// Copy platform data into vertex buffer
VertexBuffer = new FLandscapeVertexBufferMobile(PlatformData.GetData(), VertexBufferSize);
FLandscapeVertexFactoryMobile* LandscapeVertexFactory = new FLandscapeVertexFactoryMobile();
LandscapeVertexFactory->MobileData.PositionComponent = FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FLandscapeMobileVertex,Position), sizeof(FLandscapeMobileVertex), VET_UByte4N);
for( uint32 Index = 0; Index < LANDSCAPE_MAX_ES_LOD_COMP; ++Index )
{
LandscapeVertexFactory->MobileData.LODHeightsComponent.Add
(FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FLandscapeMobileVertex,LODHeights) + sizeof(uint8) * 4 * Index, sizeof(FLandscapeMobileVertex), VET_UByte4N));
}
LandscapeVertexFactory->InitResource();
VertexFactory = LandscapeVertexFactory;
// Assign LandscapeUniformShaderParameters
LandscapeUniformShaderParameters.InitResource();
PlatformData.Empty();
}
static inline void mcc_rpn(int level, uint8_t *ptr, unsigned int len,
long_frame_head *head, mcc_long_frame_head *mcc_head)
{
rpn_msg *rpn = (void *) (ptr - STRUCT_END(rpn_msg, mcc_s_head));
printf("RPN %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
p_indent(level, 0);
printf("dlci %d ", GET_DLCI(rpn->dlci));
/* Assuming that rpn_val is _declared_ as a member of rpn_msg... */
if (len <= STRUCT_OFFSET(rpn_msg, rpn_val) - STRUCT_END(rpn_msg, mcc_s_head)) {
printf("\n");
return;
}
printf("br %d db %d sb %d p %d pt %d xi %d xo %d\n",
rpn->rpn_val.bit_rate, rpn->rpn_val.data_bits,
rpn->rpn_val.stop_bit, rpn->rpn_val.parity,
rpn->rpn_val.parity_type, rpn->rpn_val.xon_input,
rpn->rpn_val.xon_output);
p_indent(level, 0);
printf("rtri %d rtro %d rtci %d rtco %d xon %d xoff %d pm 0x%04x\n",
rpn->rpn_val.rtr_input, rpn->rpn_val.rtr_output,
rpn->rpn_val.rtc_input, rpn->rpn_val.rtc_output,
rpn->rpn_val.xon, rpn->rpn_val.xoff, btohs(rpn->rpn_val.pm));
}
void FSplineMeshSceneProxy::InitVertexFactory(USplineMeshComponent* InComponent, int32 InLODIndex, FColorVertexBuffer* InOverrideColorVertexBuffer)
{
uint32 TangentXOffset = 0;
uint32 TangetnZOffset = 0;
uint32 UVsBaseOffset = 0;
auto& RD = InComponent->StaticMesh->RenderData->LODResources[InLODIndex];
SELECT_STATIC_MESH_VERTEX_TYPE(
RD.VertexBuffer.GetUseHighPrecisionTangentBasis(),
RD.VertexBuffer.GetUseFullPrecisionUVs(),
RD.VertexBuffer.GetNumTexCoords(),
{
TangentXOffset = STRUCT_OFFSET(VertexType, TangentX);
TangetnZOffset = STRUCT_OFFSET(VertexType, TangentZ);
UVsBaseOffset = STRUCT_OFFSET(VertexType, UVs);
});
static gboolean transaction_parser(GObject *conn,
GObject *transaction,
gpointer data)
{
#define PREFIX "com.nokia.policy."
(void)conn;
(void)data;
static argdsc_t dspuser_args [] = {
{ argtype_integer , "pid" , STRUCT_OFFSET(user_t, pid) },
{ argtype_invalid , NULL , 0 }
};
static actdsc_t actions[] = {
{ PREFIX "dsp_user", dspuser_action, dspuser_args, sizeof(user_t) },
{ NULL , NULL , NULL , 0 }
};
guint txid;
GSList *entry, *list;
char *name;
actdsc_t *action;
gboolean success;
gchar *signal;
OHM_DEBUG(DBG_ACTION, "got actions");
g_object_get(transaction, "txid" , &txid , NULL);
g_object_get(transaction, "facts" , &list , NULL);
g_object_get(transaction, "signal", &signal, NULL);
success = TRUE;
if (!strcmp(signal, "dsp_actions")) {
OHM_DEBUG(DBG_ACTION, "txid: %d", txid);
memset(users, 0, sizeof(users));
nuser = 0;
for (entry = list; entry != NULL; entry = g_slist_next(entry)) {
name = (char *)entry->data;
for (action = actions; action->name != NULL; action++) {
if (!strcmp(name, action->name))
success &= action_parser(action);
}
}
success = dsp_set_users(users, nuser);
}
g_free(signal);
return success;
#undef PREFIX
}
/** Allocate and return a structure capable of holding an Extended
* ORPort message of body length <b>len</b>. */
ext_or_cmd_t *
ext_or_cmd_new(uint16_t len)
{
size_t size = STRUCT_OFFSET(ext_or_cmd_t, body) + len;
ext_or_cmd_t *cmd = tor_malloc(size);
cmd->len = len;
return cmd;
}
/** Allocate a new memory pool to hold items of size <b>item_size</b>. We'll
* try to fit about <b>chunk_capacity</b> bytes in each chunk. */
mp_pool_t *
mp_pool_new(size_t item_size, size_t chunk_capacity)
{
mp_pool_t *pool;
size_t alloc_size, new_chunk_cap;
tor_assert(item_size < SIZE_T_CEILING);
tor_assert(chunk_capacity < SIZE_T_CEILING);
tor_assert(SIZE_T_CEILING / item_size > chunk_capacity);
pool = ALLOC(sizeof(mp_pool_t));
CHECK_ALLOC(pool);
memset(pool, 0, sizeof(mp_pool_t));
/* First, we figure out how much space to allow per item. We'll want to
* use make sure we have enough for the overhead plus the item size. */
alloc_size = (size_t)(STRUCT_OFFSET(mp_allocated_t, u.mem) + item_size);
/* If the item_size is less than sizeof(next_free), we need to make
* the allocation bigger. */
if (alloc_size < sizeof(mp_allocated_t))
alloc_size = sizeof(mp_allocated_t);
/* If we're not an even multiple of ALIGNMENT, round up. */
if (alloc_size % ALIGNMENT) {
alloc_size = alloc_size + ALIGNMENT - (alloc_size % ALIGNMENT);
}
if (alloc_size < ALIGNMENT)
alloc_size = ALIGNMENT;
ASSERT((alloc_size % ALIGNMENT) == 0);
/* Now we figure out how many items fit in each chunk. We need to fit at
* least 2 items per chunk. No chunk can be more than MAX_CHUNK bytes long,
* or less than MIN_CHUNK. */
if (chunk_capacity > MAX_CHUNK)
chunk_capacity = MAX_CHUNK;
/* Try to be around a power of 2 in size, since that's what allocators like
* handing out. 512K-1 byte is a lot better than 512K+1 byte. */
chunk_capacity = (size_t) round_to_power_of_2(chunk_capacity);
while (chunk_capacity < alloc_size * 2 + CHUNK_OVERHEAD)
chunk_capacity *= 2;
if (chunk_capacity < MIN_CHUNK)
chunk_capacity = MIN_CHUNK;
new_chunk_cap = (chunk_capacity-CHUNK_OVERHEAD) / alloc_size;
tor_assert(new_chunk_cap < INT_MAX);
pool->new_chunk_capacity = (int)new_chunk_cap;
pool->item_alloc_size = alloc_size;
log_debug(LD_MM, "Capacity is %lu, item size is %lu, alloc size is %lu",
(unsigned long)pool->new_chunk_capacity,
(unsigned long)pool->item_alloc_size,
(unsigned long)(pool->new_chunk_capacity*pool->item_alloc_size));
return pool;
}
/** Default constructor. */
FTileVertexFactory()
{
FLocalVertexFactory::DataType Data;
// position
Data.PositionComponent = FVertexStreamComponent(
>ileRendererVertexBuffer,STRUCT_OFFSET(FMaterialTileVertex,Position),sizeof(FMaterialTileVertex),VET_Float3);
// tangents
Data.TangentBasisComponents[0] = FVertexStreamComponent(
>ileRendererVertexBuffer,STRUCT_OFFSET(FMaterialTileVertex,TangentX),sizeof(FMaterialTileVertex),VET_PackedNormal);
Data.TangentBasisComponents[1] = FVertexStreamComponent(
>ileRendererVertexBuffer,STRUCT_OFFSET(FMaterialTileVertex,TangentZ),sizeof(FMaterialTileVertex),VET_PackedNormal);
// color
Data.ColorComponent = FVertexStreamComponent(
>ileRendererVertexBuffer,STRUCT_OFFSET(FMaterialTileVertex,Color),sizeof(FMaterialTileVertex),VET_Color);
// UVs
Data.TextureCoordinates.Add(FVertexStreamComponent(
>ileRendererVertexBuffer,STRUCT_OFFSET(FMaterialTileVertex,U),sizeof(FMaterialTileVertex),VET_Float2));
// update the data
SetData(Data);
}
void UClassProperty::CheckValidObject(void* Value) const
{
#if WITH_EDITOR
// Ugly hack to replace Blueprint references with Class references.
struct FReplaceBlueprintWithClassHelper
{
bool bShouldReplace;
UClass* BlueprintClass;
UClassProperty* BPGeneratedClassProp;
FReplaceBlueprintWithClassHelper() : bShouldReplace(false), BlueprintClass(NULL), BPGeneratedClassProp(NULL)
{
GConfig->GetBool(TEXT("EditoronlyBP"), TEXT("bReplaceBlueprintWithClass"), bShouldReplace, GEditorIni);
if (bShouldReplace)
{
BlueprintClass = FindObject<UClass>(NULL, TEXT("/Script/Engine.Blueprint"));
ensure(BlueprintClass);
BPGeneratedClassProp = BlueprintClass ? FindField<UClassProperty>(BlueprintClass, TEXT("GeneratedClass")) : NULL;
ensure(BPGeneratedClassProp);
}
}
bool CanReplace() const
{
return bShouldReplace && BlueprintClass && BPGeneratedClassProp;
}
};
static FReplaceBlueprintWithClassHelper Helper;
const UObject* Object = GetObjectPropertyValue(Value);
Super::CheckValidObject(Value);
const UObject* CurrentObject = GetObjectPropertyValue(Value);
if (Helper.CanReplace()
&& !CurrentObject
&& Object
&& Object->IsA(Helper.BlueprintClass)
&& (UObject::StaticClass() == MetaClass))
{
UObject* RecoveredObject = Helper.BPGeneratedClassProp->GetPropertyValue_InContainer(Object);
SetObjectPropertyValue(Value, RecoveredObject);
UE_LOG(LogProperty, Log,
TEXT("Blueprint '%s' is replaced with class '%s' in property '%s'"),
*Object->GetFullName(),
*RecoveredObject->GetFullName(),
*GetFullName());
}
#else // WITH_EDITOR
Super::CheckValidObject(Value);
#endif // WITH_EDITOR
}
void FSlateVertexDeclaration::InitRHI()
{
FVertexDeclarationElementList Elements;
uint32 Stride = sizeof(FSlateVertex);
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FSlateVertex, TexCoords), VET_Float4, 0, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FSlateVertex, Position), VET_Float2, 1, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FSlateVertex, ClipRect) + STRUCT_OFFSET(FSlateRotatedClipRectType, TopLeft), VET_Float2, 2, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FSlateVertex, ClipRect) + STRUCT_OFFSET(FSlateRotatedClipRectType, ExtentX), VET_Float4, 3, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FSlateVertex, Color), VET_Color, 4, Stride));
VertexDeclarationRHI = RHICreateVertexDeclaration(Elements);
}
/** Init function that should only be called on render thread. */
void Init_RenderThread(const FProcMeshVertexBuffer* VertexBuffer)
{
check(IsInRenderingThread());
// Initialize the vertex factory's stream components.
DataType NewData;
NewData.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, Position, VET_Float3);
NewData.TextureCoordinates.Add(
FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FDynamicMeshVertex, TextureCoordinate), sizeof(FDynamicMeshVertex), VET_Float2)
);
NewData.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentX, VET_PackedNormal);
NewData.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentZ, VET_PackedNormal);
NewData.ColorComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, Color, VET_Color);
SetData(NewData);
}
virtual void InitRHI() override
{
uint16 Stride = sizeof(FDistortionVertex);
FVertexDeclarationElementList Elements;
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, Position),VET_Float2,0, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, TexR), VET_Float2, 1, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, TexG), VET_Float2, 2, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, TexB), VET_Float2, 3, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, VignetteFactor), VET_Float1, 4, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, TimewarpFactor), VET_Float1, 5, Stride));
VertexDeclarationRHI = RHICreateVertexDeclaration(Elements);
}
u_int32_t
pmcCalcCrc_T01 (void *bufp)
{
FLD_TYPE2 *buf = bufp;
u_int32_t crc; /* CRC of the structure */
/* Calc CRC for type and length fields */
sbeCrc (
(u_int8_t *) &buf->type,
(u_int32_t) STRUCT_OFFSET (FLD_TYPE1, Crc32),
(u_int32_t) 0,
(u_int32_t *) &crc);
#ifdef EEPROM_TYPE_DEBUG
pr_info("sbeCrc: crc 1 calculated as %08x\n", crc); /* RLD DEBUG */
#endif
return ~crc;
}
u_int32_t
pmcCalcCrc_T01 (void *bufp)
{
FLD_TYPE2 *buf = bufp;
u_int32_t crc; /* */
/* */
sbeCrc (
(u_int8_t *) &buf->type,
(u_int32_t) STRUCT_OFFSET (FLD_TYPE1, Crc32),
(u_int32_t) 0,
(u_int32_t *) &crc);
#ifdef EEPROM_TYPE_DEBUG
pr_info("sbeCrc: crc 1 calculated as %08x\n", crc); /* */
#endif
return ~crc;
}
void FPaperSpriteVertexFactory::Init(const FPaperSpriteVertexBuffer* InVertexBuffer)
{
check(!IsInRenderingThread());
ENQUEUE_UNIQUE_RENDER_COMMAND_TWOPARAMETER(
InitPaperSpriteVertexFactory,
FPaperSpriteVertexFactory*,VertexFactory,this,
const FPaperSpriteVertexBuffer*,VB,InVertexBuffer,
{
// Initialize the vertex factory's stream components.
DataType NewData;
NewData.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VB,FPaperSpriteVertex,Position,VET_Float3);
NewData.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VB,FPaperSpriteVertex,TangentX,VET_PackedNormal);
NewData.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VB,FPaperSpriteVertex,TangentZ,VET_PackedNormal);
NewData.ColorComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VB,FPaperSpriteVertex,Color,VET_Color);
NewData.TextureCoordinates.Add(FVertexStreamComponent(VB, STRUCT_OFFSET(FPaperSpriteVertex,TexCoords), sizeof(FPaperSpriteVertex), VET_Float2));
VertexFactory->SetData(NewData);
});
static void init_callback(void *msg)
{
load_parameter(STRUCT_OFFSET(PARAMETER, cr_mode_resist_set), &s_cr_mode_resist_set, sizeof(s_cr_mode_resist_set));
draw_cr_mode_menu();
s_cur_resist = s_cr_mode_resist_set;
draw_focus_resist_val(s_cur_resist);
draw_ac_val(0);
draw_voltage_val(0);
draw_current_val(0);
lcd_validate_cmd();
s_cr_mode = CR_FOCUS_MODE;
}
/** Initialization */
void Init(const FTerrainMeshVertexBuffer* VertexBuffer)
{
// Commented out to enable building light of a level (but no backing is done for the procedural mesh itself)
//check(!IsInRenderingThread());
ENQUEUE_UNIQUE_RENDER_COMMAND_TWOPARAMETER(
InitTerrainMeshVertexFactory,
FTerrainMeshVertexFactory*, VertexFactory, this,
const FTerrainMeshVertexBuffer*, VertexBuffer, VertexBuffer,
{
// Initialize the vertex factory's stream components.
DataType NewData;
NewData.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, Position, VET_Float3);
NewData.TextureCoordinates.Add(
FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FDynamicMeshVertex, TextureCoordinate), sizeof(FDynamicMeshVertex), VET_Float2)
);
NewData.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentX, VET_PackedNormal);
NewData.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentZ, VET_PackedNormal);
NewData.ColorComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, Color, VET_Color);
VertexFactory->SetData(NewData);
});
static inline void mcc_msc(int level, uint8_t *ptr, unsigned int len,
long_frame_head *head, mcc_long_frame_head *mcc_head)
{
msc_msg *msc = (void*) (ptr - STRUCT_END(msc_msg, mcc_s_head));
printf("MSC %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
p_indent(level, 0);
printf("dlci %d fc %d rtc %d rtr %d ic %d dv %d",
GET_DLCI(msc->dlci), msc->v24_sigs.fc, msc->v24_sigs.rtc,
msc->v24_sigs.rtr, msc->v24_sigs.ic, msc->v24_sigs.dv );
/* Assuming that break_signals field is _not declared_ in struct msc_msg... */
if (len > STRUCT_OFFSET(msc_msg, fcs) - STRUCT_END(msc_msg, v24_sigs)) {
break_signals *brk = (break_signals *)
(ptr + STRUCT_END(msc_msg, v24_sigs));
printf(" b1 %d b2 %d b3 %d len %d\n",
brk->b1, brk->b2, brk->b3, brk->len);
} else
printf("\n");
}
void FSlateVertexDeclaration::InitRHI()
{
FVertexDeclarationElementList Elements;
uint32 Stride = sizeof(FSlateVertex);
Elements.Add(FVertexElement(0,STRUCT_OFFSET(FSlateVertex,TexCoords),VET_Float4,0,Stride));
Elements.Add(FVertexElement(0,STRUCT_OFFSET(FSlateVertex,Position),VET_Short2,1,Stride));
bool bUseFloat16 =
#if SLATE_USE_FLOAT16
true;
#else
false;
#endif
Elements.Add(FVertexElement(0,STRUCT_OFFSET(FSlateVertex,ClipRect),bUseFloat16 ? VET_Half2 : VET_Float2,2,Stride));
Elements.Add(FVertexElement(0,STRUCT_OFFSET(FSlateVertex,ClipRect)+STRUCT_OFFSET(FSlateRotatedClipRectType,ExtentX),bUseFloat16 ? VET_Half4 : VET_Float4,3,Stride));
Elements.Add(FVertexElement(0,STRUCT_OFFSET(FSlateVertex,Color),VET_Color,4,Stride));
VertexDeclarationRHI = RHICreateVertexDeclaration(Elements);
}
for(TMap<UMaterialInterface*,TScopedPointer<FRawIndexBuffer16or32> >::TConstIterator IndexBufferIt(MaterialIndexBuffers);IndexBufferIt;++IndexBufferIt)
{
const TScopedPointer<FRawIndexBuffer16or32> &IndexBuffer = IndexBufferIt.Value();
ResourceSize += IndexBuffer->Indices.Num() * sizeof(uint32);
}
return ResourceSize;
}
#if WITH_EDITOR
IMPLEMENT_INTRINSIC_CLASS(UModel, ENGINE_API, UObject, CORE_API,
{
Class->ClassAddReferencedObjects = &UModel::AddReferencedObjects;
Class->EmitObjectReference( STRUCT_OFFSET( UModel, Polys ) );
const uint32 SkipIndexIndex = Class->EmitStructArrayBegin( STRUCT_OFFSET( UModel, Surfs ), sizeof(FBspSurf) );
Class->EmitObjectReference( STRUCT_OFFSET( FBspSurf, Material ) );
Class->EmitObjectReference( STRUCT_OFFSET( FBspSurf, Actor ) );
Class->EmitStructArrayEnd( SkipIndexIndex );
}
);
#else
IMPLEMENT_INTRINSIC_CLASS(UModel, ENGINE_API, UObject, CORE_API,
{
Class->ClassAddReferencedObjects = &UModel::AddReferencedObjects;
const uint32 SkipIndexIndex = Class->EmitStructArrayBegin( STRUCT_OFFSET( UModel, Surfs ), sizeof(FBspSurf) );
Class->EmitObjectReference( STRUCT_OFFSET( FBspSurf, Material ) );
Class->EmitObjectReference( STRUCT_OFFSET( FBspSurf, Actor ) );
Class->EmitStructArrayEnd( SkipIndexIndex );
if( !(MetaClass||HasAnyFlags(RF_ClassDefaultObject)) )
{
// If we failed to load the MetaClass and we're not a CDO, that means we relied on a class that has been removed or doesn't exist.
// The most likely cause for this is either an incomplete recompile, or if content was migrated between games that had native class dependencies
// that do not exist in this game. We allow blueprint classes to continue, because compile on load will error out, and stub the class that was using it
UClass* TestClass = dynamic_cast<UClass*>(GetOwnerStruct());
if( TestClass && TestClass->HasAllClassFlags(CLASS_Native) && !TestClass->HasAllClassFlags(CLASS_NewerVersionExists) && (TestClass->GetOutermost() != GetTransientPackage()) )
{
checkf(false, TEXT("Class property tried to serialize a missing class. Did you remove a native class and not fully recompile?"));
}
}
}
void UAssetClassProperty::AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector)
{
UAssetClassProperty* This = CastChecked<UAssetClassProperty>(InThis);
Collector.AddReferencedObject( This->MetaClass, This );
Super::AddReferencedObjects( This, Collector );
}
bool UAssetClassProperty::SameType(const UProperty* Other) const
{
return Super::SameType(Other) && (MetaClass == ((UAssetClassProperty*)Other)->MetaClass);
}
IMPLEMENT_CORE_INTRINSIC_CLASS(UAssetClassProperty, UAssetObjectProperty,
{
Class->EmitObjectReference(STRUCT_OFFSET(UAssetClassProperty, MetaClass), TEXT("MetaClass"));
}
);
static void LogGetPackageLinkerError(FArchiveUObject* LinkerArchive, const TCHAR* InFilename, const FText& InFullErrorMessage, const FText& InSummaryErrorMessage, UObject* InOuter, uint32 LoadFlags)
{
static FName NAME_LoadErrors("LoadErrors");
struct Local
{
/** Helper function to output more detailed error info if available */
static void OutputErrorDetail(FArchiveUObject* LinkerArchive, const FName& LogName)
{
if ( GSerializedObject && GSerializedImportLinker )
{
FMessageLog LoadErrors(LogName);
TSharedRef<FTokenizedMessage> Message = LoadErrors.Info();
Message->AddToken(FTextToken::Create(LOCTEXT("FailedLoad_Message", "Failed to load")));
Message->AddToken(FAssetNameToken::Create(GSerializedImportLinker->GetImportPathName(GSerializedImportIndex)));
Message->AddToken(FTextToken::Create(LOCTEXT("FailedLoad_Referenced", "Referenced by")));
Message->AddToken(FUObjectToken::Create(GSerializedObject));
auto SerializedProperty = LinkerArchive ? LinkerArchive->GetSerializedProperty() : nullptr;
if (SerializedProperty != nullptr)
{
FString PropertyPathName = SerializedProperty->GetPathName();
Message->AddToken(FTextToken::Create(LOCTEXT("FailedLoad_Property", "Property")));
Message->AddToken(FAssetNameToken::Create(PropertyPathName, FText::FromString( PropertyPathName) ) );
}
}
}
};
FMessageLog LoadErrors(NAME_LoadErrors);
// Display log error regardless LoadFlag settings
SET_WARN_COLOR(COLOR_RED);
if (LoadFlags & LOAD_NoWarn)
{
UE_LOG(LogLinker, Log, TEXT("%s"), *InFullErrorMessage.ToString());
}
else
{
UE_LOG(LogLinker, Warning, TEXT("%s"), *InFullErrorMessage.ToString());
}
CLEAR_WARN_COLOR();
if( GIsEditor && !IsRunningCommandlet() )
{
// if we don't want to be warned, skip the load warning
if (!(LoadFlags & LOAD_NoWarn))
{
// we only want to output errors that content creators will be able to make sense of,
// so any errors we cant get links out of we will just let be output to the output log (above)
// rather than clog up the message log
if(InFilename != NULL && InOuter != NULL)
{
// Output the summary error & the filename link. This might be something like "..\Content\Foo.upk Out of Memory"
TSharedRef<FTokenizedMessage> Message = LoadErrors.Error();
Message->AddToken(FAssetNameToken::Create(FPackageName::FilenameToLongPackageName(InFilename)));
Message->AddToken(FTextToken::Create(FText::FromString(TEXT(":"))));
Message->AddToken(FTextToken::Create(InSummaryErrorMessage));
Message->AddToken(FAssetNameToken::Create(FPackageName::FilenameToLongPackageName(InOuter->GetPathName())));
}
Local::OutputErrorDetail(LinkerArchive, NAME_LoadErrors);
}
}
else
{
if (!(LoadFlags & LOAD_NoWarn))
{
Local::OutputErrorDetail(LinkerArchive, NAME_LoadErrors);
}
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("FileName"), FText::FromString(InFilename ? InFilename : InOuter ? *InOuter->GetName() : TEXT("NULL")));
Arguments.Add(TEXT("ErrorMessage"), InFullErrorMessage);
const FText Error = FText::Format(LOCTEXT("FailedLoad", "Failed to load '{FileName}': {ErrorMessage}"), Arguments);
// @see ResavePackagesCommandlet
if( FParse::Param(FCommandLine::Get(),TEXT("SavePackagesThatHaveFailedLoads")) == true )
{
LoadErrors.Warning(Error);
}
else
{
// Gracefully handle missing packages
SafeLoadError( InOuter, LoadFlags, *InFullErrorMessage.ToString(), *Error.ToString() );
}
}
}
/** Run unit tests for heap-based priority queue functions. */
static void
test_container_pqueue(void)
{
smartlist_t *sl = smartlist_new();
int (*cmp)(const void *, const void*);
const int offset = STRUCT_OFFSET(pq_entry_t, idx);
#define ENTRY(s) pq_entry_t s = { #s, -1 }
ENTRY(cows);
ENTRY(zebras);
ENTRY(fish);
ENTRY(frogs);
ENTRY(apples);
ENTRY(squid);
ENTRY(daschunds);
ENTRY(eggplants);
ENTRY(weissbier);
ENTRY(lobsters);
ENTRY(roquefort);
ENTRY(chinchillas);
ENTRY(fireflies);
#define OK() smartlist_pqueue_assert_ok(sl, cmp, offset)
cmp = compare_strings_for_pqueue_;
smartlist_pqueue_add(sl, cmp, offset, &cows);
smartlist_pqueue_add(sl, cmp, offset, &zebras);
smartlist_pqueue_add(sl, cmp, offset, &fish);
smartlist_pqueue_add(sl, cmp, offset, &frogs);
smartlist_pqueue_add(sl, cmp, offset, &apples);
smartlist_pqueue_add(sl, cmp, offset, &squid);
smartlist_pqueue_add(sl, cmp, offset, &daschunds);
smartlist_pqueue_add(sl, cmp, offset, &eggplants);
smartlist_pqueue_add(sl, cmp, offset, &weissbier);
smartlist_pqueue_add(sl, cmp, offset, &lobsters);
smartlist_pqueue_add(sl, cmp, offset, &roquefort);
OK();
test_eq(smartlist_len(sl), 11);
test_eq_ptr(smartlist_get(sl, 0), &apples);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &apples);
test_eq(smartlist_len(sl), 10);
OK();
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &cows);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &daschunds);
smartlist_pqueue_add(sl, cmp, offset, &chinchillas);
OK();
smartlist_pqueue_add(sl, cmp, offset, &fireflies);
OK();
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &chinchillas);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &eggplants);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &fireflies);
OK();
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &fish);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &frogs);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &lobsters);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &roquefort);
OK();
test_eq(smartlist_len(sl), 3);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &squid);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &weissbier);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &zebras);
test_eq(smartlist_len(sl), 0);
OK();
/* Now test remove. */
smartlist_pqueue_add(sl, cmp, offset, &cows);
smartlist_pqueue_add(sl, cmp, offset, &fish);
smartlist_pqueue_add(sl, cmp, offset, &frogs);
smartlist_pqueue_add(sl, cmp, offset, &apples);
smartlist_pqueue_add(sl, cmp, offset, &squid);
smartlist_pqueue_add(sl, cmp, offset, &zebras);
test_eq(smartlist_len(sl), 6);
OK();
smartlist_pqueue_remove(sl, cmp, offset, &zebras);
test_eq(smartlist_len(sl), 5);
OK();
smartlist_pqueue_remove(sl, cmp, offset, &cows);
test_eq(smartlist_len(sl), 4);
OK();
smartlist_pqueue_remove(sl, cmp, offset, &apples);
test_eq(smartlist_len(sl), 3);
OK();
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &fish);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &frogs);
test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &squid);
test_eq(smartlist_len(sl), 0);
OK();
#undef OK
done:
smartlist_free(sl);
}
else
{
Super::ExportTextItem(ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope);
}
}
const TCHAR* UByteProperty::ImportText_Internal( const TCHAR* InBuffer, void* Data, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText ) const
{
FString Temp;
if( Enum && (PortFlags & PPF_ConsoleVariable) == 0 )
{
const TCHAR* Buffer = UPropertyHelpers::ReadToken( InBuffer, Temp, true );
if( Buffer != NULL )
{
const int32 EnumIndex = Enum->FindEnumIndex( *Temp );
if( EnumIndex != INDEX_NONE )
{
*(uint8*)Data = EnumIndex;
return Buffer;
}
}
}
return Super::ImportText_Internal( InBuffer, Data, PortFlags, Parent, ErrorText );
}
IMPLEMENT_CORE_INTRINSIC_CLASS(UByteProperty, UNumericProperty,
{
Class->EmitObjectReference(STRUCT_OFFSET(UByteProperty, Enum), TEXT("Enum"));
}
);
static REBOOL get_scalar(const REBSTU *stu,
const struct Struct_Field *field,
REBCNT n, /* element index, starting from 0 */
REBVAL *val)
{
REBYTE *data = SERIES_SKIP(STRUCT_DATA_BIN(stu),
STRUCT_OFFSET(stu) + field->offset + n * field->size);
switch (field->type) {
case STRUCT_TYPE_UINT8:
SET_INTEGER(val, *(u8*)data);
break;
case STRUCT_TYPE_INT8:
SET_INTEGER(val, *(i8*)data);
break;
case STRUCT_TYPE_UINT16:
SET_INTEGER(val, *(u16*)data);
break;
case STRUCT_TYPE_INT16:
SET_INTEGER(val, *(i8*)data);
break;
case STRUCT_TYPE_UINT32:
SET_INTEGER(val, *(u32*)data);
break;
case STRUCT_TYPE_INT32:
SET_INTEGER(val, *(i32*)data);
break;
case STRUCT_TYPE_UINT64:
SET_INTEGER(val, *(u64*)data);
break;
case STRUCT_TYPE_INT64:
SET_INTEGER(val, *(i64*)data);
break;
case STRUCT_TYPE_FLOAT:
SET_DECIMAL(val, *(float*)data);
break;
case STRUCT_TYPE_DOUBLE:
SET_DECIMAL(val, *(double*)data);
break;
case STRUCT_TYPE_POINTER:
SET_INTEGER(val, cast(REBUPT, *cast(void**, data)));
break;
case STRUCT_TYPE_STRUCT:
{
SET_TYPE(val, REB_STRUCT);
VAL_STRUCT_FIELDS(val) = field->fields;
VAL_STRUCT_SPEC(val) = field->spec;
VAL_STRUCT_DATA(val) = Make_Series(
1, sizeof(struct Struct_Data), MKS_NONE
);
MANAGE_SERIES(VAL_STRUCT_DATA(val));
VAL_STRUCT_DATA_BIN(val) = STRUCT_DATA_BIN(stu);
VAL_STRUCT_OFFSET(val) = data - SERIES_DATA(VAL_STRUCT_DATA_BIN(val));
VAL_STRUCT_LEN(val) = field->size;
}
break;
case STRUCT_TYPE_REBVAL:
memcpy(val, data, sizeof(REBVAL));
break;
default:
/* should never be here */
return FALSE;
}
return TRUE;
}
static REBOOL assign_scalar(REBSTU *stu,
struct Struct_Field *field,
REBCNT n, /* element index, starting from 0 */
REBVAL *val)
{
u64 i = 0;
double d = 0;
void *data = SERIES_SKIP(STRUCT_DATA_BIN(stu),
STRUCT_OFFSET(stu) + field->offset + n * field->size);
if (field->type == STRUCT_TYPE_REBVAL) {
memcpy(data, val, sizeof(REBVAL));
return TRUE;
}
switch (VAL_TYPE(val)) {
case REB_DECIMAL:
if (!IS_NUMERIC_TYPE(field->type))
raise Error_Has_Bad_Type(val);
d = VAL_DECIMAL(val);
i = (u64) d;
break;
case REB_INTEGER:
if (!IS_NUMERIC_TYPE(field->type))
if (field->type != STRUCT_TYPE_POINTER)
raise Error_Has_Bad_Type(val);
i = (u64) VAL_INT64(val);
d = (double)i;
break;
case REB_STRUCT:
if (STRUCT_TYPE_STRUCT != field->type)
raise Error_Has_Bad_Type(val);
break;
default:
raise Error_Has_Bad_Type(val);
}
switch (field->type) {
case STRUCT_TYPE_INT8:
*(i8*)data = (i8)i;
break;
case STRUCT_TYPE_UINT8:
*(u8*)data = (u8)i;
break;
case STRUCT_TYPE_INT16:
*(i16*)data = (i16)i;
break;
case STRUCT_TYPE_UINT16:
*(u16*)data = (u16)i;
break;
case STRUCT_TYPE_INT32:
*(i32*)data = (i32)i;
break;
case STRUCT_TYPE_UINT32:
*(u32*)data = (u32)i;
break;
case STRUCT_TYPE_INT64:
*(i64*)data = (i64)i;
break;
case STRUCT_TYPE_UINT64:
*(u64*)data = (u64)i;
break;
case STRUCT_TYPE_POINTER:
*cast(void**, data) = cast(void*, cast(REBUPT, i));
break;
case STRUCT_TYPE_FLOAT:
*(float*)data = (float)d;
break;
case STRUCT_TYPE_DOUBLE:
*(double*)data = (double)d;
break;
case STRUCT_TYPE_STRUCT:
if (field->size != VAL_STRUCT_LEN(val))
raise Error_Invalid_Arg(val);
if (same_fields(field->fields, VAL_STRUCT_FIELDS(val))) {
memcpy(data, SERIES_SKIP(VAL_STRUCT_DATA_BIN(val), VAL_STRUCT_OFFSET(val)), field->size);
} else
raise Error_Invalid_Arg(val);
break;
default:
/* should never be here */
return FALSE;
}
return TRUE;
}
{ NULL, CONFIG_TYPE_OBSOLETE, 0, NULL }
};
#undef VAR
#undef V
static int or_state_validate(or_state_t *old_options, or_state_t *options,
int from_setconf, char **msg);
/** Magic value for or_state_t. */
#define OR_STATE_MAGIC 0x57A73f57
/** "Extra" variable in the state that receives lines we can't parse. This
* lets us preserve options from versions of Tor newer than us. */
static config_var_t state_extra_var = {
"__extra", CONFIG_TYPE_LINELIST, STRUCT_OFFSET(or_state_t, ExtraLines), NULL
};
/** Configuration format for or_state_t. */
static const config_format_t state_format = {
sizeof(or_state_t),
OR_STATE_MAGIC,
STRUCT_OFFSET(or_state_t, _magic),
_state_abbrevs,
_state_vars,
(validate_fn_t)or_state_validate,
&state_extra_var,
};
/** Persistent serialized state. */
static or_state_t *global_state = NULL;