FShaderType::FShaderType(
const TCHAR* InName,
const TCHAR* InSourceFilename,
const TCHAR* InFunctionName,
uint32 InFrequency,
ConstructSerializedType InConstructSerializedRef
):
Name(InName),
SourceFilename(InSourceFilename),
FunctionName(InFunctionName),
Frequency(InFrequency),
ConstructSerializedRef(InConstructSerializedRef),
GlobalListLink(this)
{
for (int32 Platform = 0; Platform < SP_NumPlatforms; Platform++)
{
bCachedUniformBufferStructDeclarations[Platform] = false;
}
// This will trigger if an IMPLEMENT_SHADER_TYPE was in a module not loaded before InitializeShaderTypes
// Shader types need to be implemented in modules that are loaded before that
checkf(!bInitializedSerializationHistory, TEXT("Shader type was loaded after engine init, use ELoadingPhase::PostConfigInit on your module to cause it to load earlier."));
//make sure the name is shorter than the maximum serializable length
check(FCString::Strlen(InName) < NAME_SIZE);
// register this shader type
GlobalListLink.Link(GetTypeList());
GetNameToTypeMap().Add(FName(InName), this);
// Assign the shader type the next unassigned hash index.
static uint32 NextHashIndex = 0;
HashIndex = NextHashIndex++;
}
FShaderPipelineType::FShaderPipelineType(
const TCHAR* InName,
const FShaderType* InVertexShader,
const FShaderType* InHullShader,
const FShaderType* InDomainShader,
const FShaderType* InGeometryShader,
const FShaderType* InPixelShader,
bool bInShouldOptimizeUnusedOutputs) :
Name(InName),
TypeName(Name),
GlobalListLink(this),
bShouldOptimizeUnusedOutputs(bInShouldOptimizeUnusedOutputs)
{
checkf(Name && *Name, TEXT("Shader Pipeline Type requires a valid Name!"));
checkf(InVertexShader, TEXT("A Shader Pipeline always requires a Vertex Shader"));
checkf((InHullShader == nullptr && InDomainShader == nullptr) || (InHullShader != nullptr && InDomainShader != nullptr), TEXT("Both Hull & Domain shaders are needed for tessellation on Pipeline %s"), Name);
//make sure the name is shorter than the maximum serializable length
check(FCString::Strlen(InName) < NAME_SIZE);
FMemory::Memzero(AllStages);
if (InPixelShader)
{
Stages.Add(InPixelShader);
AllStages[SF_Pixel] = InPixelShader;
}
if (InGeometryShader)
{
Stages.Add(InGeometryShader);
AllStages[SF_Geometry] = InGeometryShader;
}
if (InDomainShader)
{
Stages.Add(InDomainShader);
AllStages[SF_Domain] = InDomainShader;
Stages.Add(InHullShader);
AllStages[SF_Hull] = InHullShader;
}
Stages.Add(InVertexShader);
AllStages[SF_Vertex] = InVertexShader;
static uint32 TypeHashCounter = 0;
++TypeHashCounter;
HashIndex = TypeHashCounter;
GlobalListLink.LinkHead(GetTypeList());
GetNameToTypeMap().Add(FName(InName), this);
// This will trigger if an IMPLEMENT_SHADER_TYPE was in a module not loaded before InitializeShaderTypes
// Shader types need to be implemented in modules that are loaded before that
checkf(!bInitialized, TEXT("Shader Pipeline was loaded after Engine init, use ELoadingPhase::PostConfigInit on your module to cause it to load earlier."));
}
FMaterialUniformExpressionType::FMaterialUniformExpressionType(
const TCHAR* InName,
SerializationConstructorType InSerializationConstructor
):
Name(InName),
SerializationConstructor(InSerializationConstructor)
{
// Put the type in the type list until the name subsystem/type map are initialized.
(new TLinkedList<FMaterialUniformExpressionType*>(this))->Link(GetTypeList());
}
bool CTypesIteratorBase<Parent>::CanEnter(const CConstObjectInfo& object)
{
if ( !CParent::CanEnter(object) )
return false;
TTypeInfo type = object.GetTypeInfo();
ITERATE ( TTypeList, i, GetTypeList() ) {
if ( type->MayContainType(*i) )
return true;
}
return false;
}
/**
* Finds a FVertexFactoryType by name.
*/
FVertexFactoryType* FVertexFactoryType::GetVFByName(const FString& VFName)
{
for(TLinkedList<FVertexFactoryType*>::TIterator It(GetTypeList()); It; It.Next())
{
FString CurrentVFName = FString(It->GetName());
if (CurrentVFName == VFName)
{
return *It;
}
}
return NULL;
}
const FShaderPipelineType* FShaderPipelineType::GetShaderPipelineTypeByName(FName Name)
{
for (TLinkedList<FShaderPipelineType*>::TIterator It(GetTypeList()); It; It.Next())
{
const FShaderPipelineType* Type = *It;
if (Name == Type->GetFName())
{
return Type;
}
}
return nullptr;
}
TArray<FShaderType*> FShaderType::GetShaderTypesByFilename(const TCHAR* Filename)
{
TArray<FShaderType*> OutShaders;
for(TLinkedList<FShaderType*>::TIterator It(GetTypeList()); It; It.Next())
{
FShaderType* Type = *It;
if (FPlatformString::Strcmp(Filename, Type->GetShaderFilename()) == 0)
{
OutShaders.Add(Type);
}
}
return OutShaders;
}
FShaderType* FShaderType::GetShaderTypeByName(const TCHAR* Name)
{
for(TLinkedList<FShaderType*>::TIterator It(GetTypeList()); It; It.Next())
{
FShaderType* Type = *It;
if (FPlatformString::Strcmp(Name, Type->GetName()) == 0)
{
return Type;
}
}
return NULL;
}
bool CTypesIteratorBase<Parent>::CanSelect(const CConstObjectInfo& object)
{
if ( !CParent::CanSelect(object) )
return false;
m_MatchType = 0;
TTypeInfo type = object.GetTypeInfo();
ITERATE ( TTypeList, i, GetTypeList() ) {
if ( type->IsType(*i) ) {
m_MatchType = *i;
return true;
}
}
return false;
}
/** Retrieve a list of available variables, types and functions in PyVcl.vcl.
* \return New reference
*/
static PyObject* GlobalVcl_Dir(TVclObject *self, PyObject *arg)
{
unsigned GlobalCount = sizeof(GlobalObjectList)/sizeof(GlobalObjectList[0]);
unsigned GlobalFunctionCount = GetVclFunctionCount();
TStrings *TypeList = GetTypeList();
PyObject *List = PyList_New(TypeList->Count + GlobalCount + GlobalFunctionCount);
int Index;
for(Index = 0; Index < TypeList->Count; Index++)
PyList_SET_ITEM(List, Index, ToPyObject(TypeList->Strings[Index]));
for(unsigned I = 0; I < GlobalCount; I++, Index++)
PyList_SET_ITEM(List, Index, ToPyObject(GlobalObjectList[I].Name));
for(unsigned I = 0; I < GlobalFunctionCount; I++, Index++)
PyList_SET_ITEM(List, Index, ToPyObject(GetVclFunctionName(I)));
return List;
}
/*
* Class: magick_Magick
* Method: queryFonts
* Signature: (Ljava/lang/String;)[Ljava/lang/String;
*/
JNIEXPORT jobjectArray JNICALL Java_magick_Magick_queryFonts
(JNIEnv *env, jclass magickClass, jstring pattern)
{
char **fonts;
size_t number_fonts;
int i;
ExceptionInfo exception;
jobjectArray fontArray;
GetExceptionInfo(&exception);
fonts = GetTypeList((*env)->GetStringUTFChars(env, pattern, 0), &number_fonts, &exception);
DestroyExceptionInfo(&exception);
fontArray = (*env)->NewObjectArray(env, number_fonts, (*env)->FindClass(env, "java/lang/String"), (*env)->NewStringUTF(env, ""));
for(i = 0; i < number_fonts; i++) {
(*env)->SetObjectArrayElement(env, fontArray, i, (*env)->NewStringUTF(env, fonts[i]));
}
return fontArray;
}
void FShaderType::GetOutdatedTypes(TArray<FShaderType*>& OutdatedShaderTypes, TArray<const FVertexFactoryType*>& OutdatedFactoryTypes)
{
for(TLinkedList<FShaderType*>::TIterator It(GetTypeList()); It; It.Next())
{
FShaderType* Type = *It;
Type->GetOutdatedCurrentType(OutdatedShaderTypes, OutdatedFactoryTypes);
}
for (int32 TypeIndex = 0; TypeIndex < OutdatedShaderTypes.Num(); TypeIndex++)
{
UE_LOG(LogShaders, Warning, TEXT(" Recompiling %s"), OutdatedShaderTypes[TypeIndex]->GetName());
}
for (int32 TypeIndex = 0; TypeIndex < OutdatedFactoryTypes.Num(); TypeIndex++)
{
UE_LOG(LogShaders, Warning, TEXT(" Recompiling %s"), OutdatedFactoryTypes[TypeIndex]->GetName());
}
}
FVertexFactoryType::FVertexFactoryType(
const TCHAR* InName,
const TCHAR* InShaderFilename,
bool bInUsedWithMaterials,
bool bInSupportsStaticLighting,
bool bInSupportsDynamicLighting,
bool bInSupportsPrecisePrevWorldPos,
bool bInSupportsPositionOnly,
ConstructParametersType InConstructParameters,
ShouldCacheType InShouldCache,
ModifyCompilationEnvironmentType InModifyCompilationEnvironment,
SupportsTessellationShadersType InSupportsTessellationShaders
):
Name(InName),
ShaderFilename(InShaderFilename),
TypeName(InName),
bUsedWithMaterials(bInUsedWithMaterials),
bSupportsStaticLighting(bInSupportsStaticLighting),
bSupportsDynamicLighting(bInSupportsDynamicLighting),
bSupportsPrecisePrevWorldPos(bInSupportsPrecisePrevWorldPos),
bSupportsPositionOnly(bInSupportsPositionOnly),
ConstructParameters(InConstructParameters),
ShouldCacheRef(InShouldCache),
ModifyCompilationEnvironmentRef(InModifyCompilationEnvironment),
SupportsTessellationShadersRef(InSupportsTessellationShaders),
GlobalListLink(this)
{
for (int32 Platform = 0; Platform < SP_NumPlatforms; Platform++)
{
bCachedUniformBufferStructDeclarations[Platform] = false;
}
// This will trigger if an IMPLEMENT_VERTEX_FACTORY_TYPE was in a module not loaded before InitializeShaderTypes
// Vertex factory types need to be implemented in modules that are loaded before that
checkf(!bInitializedSerializationHistory, TEXT("VF type was loaded after engine init, use ELoadingPhase::PostConfigInit on your module to cause it to load earlier."));
// Add this vertex factory type to the global list.
GlobalListLink.LinkHead(GetTypeList());
// Assign the vertex factory type the next unassigned hash index.
HashIndex = NextHashIndex++;
}
TMap<FName,FMaterialUniformExpressionType*>& FMaterialUniformExpressionType::GetTypeMap()
{
static TMap<FName,FMaterialUniformExpressionType*> TypeMap;
// Move types from the type list to the type map.
TLinkedList<FMaterialUniformExpressionType*>* TypeListLink = GetTypeList();
while(TypeListLink)
{
TLinkedList<FMaterialUniformExpressionType*>* NextLink = TypeListLink->Next();
FMaterialUniformExpressionType* Type = **TypeListLink;
TypeMap.Add(FName(Type->Name),Type);
TypeListLink->Unlink();
delete TypeListLink;
TypeListLink = NextLink;
}
return TypeMap;
}
void FShaderType::GetOutdatedTypes(TArray<FShaderType*>& OutdatedShaderTypes, TArray<const FVertexFactoryType*>& OutdatedFactoryTypes)
{
for(TLinkedList<FShaderType*>::TIterator It(GetTypeList()); It; It.Next())
{
FShaderType* Type = *It;
for(TMap<FShaderId,FShader*>::TConstIterator ShaderIt(Type->ShaderIdMap);ShaderIt;++ShaderIt)
{
FShader* Shader = ShaderIt.Value();
const FVertexFactoryParameterRef* VFParameterRef = Shader->GetVertexFactoryParameterRef();
const FSHAHash& SavedHash = Shader->GetHash();
const FSHAHash& CurrentHash = Type->GetSourceHash();
const bool bOutdatedShader = SavedHash != CurrentHash;
const bool bOutdatedVertexFactory =
VFParameterRef && VFParameterRef->GetVertexFactoryType() && VFParameterRef->GetVertexFactoryType()->GetSourceHash() != VFParameterRef->GetHash();
if (bOutdatedShader)
{
OutdatedShaderTypes.AddUnique(Shader->Type);
}
if (bOutdatedVertexFactory)
{
OutdatedFactoryTypes.AddUnique(VFParameterRef->GetVertexFactoryType());
}
}
}
for (int32 TypeIndex = 0; TypeIndex < OutdatedShaderTypes.Num(); TypeIndex++)
{
UE_LOG(LogShaders, Warning, TEXT(" Recompiling %s"), OutdatedShaderTypes[TypeIndex]->GetName());
}
for (int32 TypeIndex = 0; TypeIndex < OutdatedFactoryTypes.Num(); TypeIndex++)
{
UE_LOG(LogShaders, Warning, TEXT(" Recompiling %s"), OutdatedFactoryTypes[TypeIndex]->GetName());
}
}
FunctionDeclaration::FunctionDeclaration(DeclarationListRef parameter_list,
const_shared_ptr<TypeSpecifier> return_type,
const yy::location location) :
FunctionTypeSpecifier(GetTypeList(parameter_list), return_type,
location), m_parameter_list(parameter_list) {
}