ezAngle ezCamera::GetFovX(float fAspectRatioWidthDivHeight) const { if (m_Mode == PerspectiveFixedFovX) return ezAngle::Degree(m_fFovOrDim); if (m_Mode == PerspectiveFixedFovY) return ezAngle::Degree(m_fFovOrDim) * fAspectRatioWidthDivHeight; EZ_REPORT_FAILURE("You cannot get the camera FOV when it is not a perspective camera."); return ezAngle(); }
void ezExpressionVM::Execute(const ezExpressionByteCode& byteCode, ezArrayPtr<const ezExpression::Stream> inputs, ezArrayPtr<ezExpression::Stream> outputs, ezUInt32 uiNumInstances) { // Input mapping { auto inputNames = byteCode.GetInputs(); m_InputMapping.Clear(); m_InputMapping.Reserve(inputNames.GetCount()); for (auto& inputName : inputNames) { bool bInputFound = false; for (ezUInt32 i = 0; i < inputs.GetCount(); ++i) { if (inputs[i].m_sName == inputName) { inputs[i].ValidateDataSize(uiNumInstances, "Input"); m_InputMapping.PushBack(i); bInputFound = true; break; } } EZ_ASSERT_DEV(bInputFound, "Bytecode expects an input '{0}'", inputName); } } // Output mapping { auto outputNames = byteCode.GetOutputs(); m_OutputMapping.Clear(); m_OutputMapping.Reserve(outputNames.GetCount()); for (auto& outputName : outputNames) { bool bOutputFound = false; for (ezUInt32 i = 0; i < outputs.GetCount(); ++i) { if (outputs[i].m_sName == outputName) { outputs[i].ValidateDataSize(uiNumInstances, "Output"); m_OutputMapping.PushBack(i); bOutputFound = true; break; } } EZ_ASSERT_DEV(bOutputFound, "Bytecode expects an output '{0}'", outputName); } } ezSimdVec4f* pRegisters = m_Registers.GetData(); const ezUInt32 uiNumRegisters = (uiNumInstances + 3) / 4; const ezUInt32 uiLastInstanceIndex = uiNumInstances - 1; const ezUInt32 uiTotalNumRegisters = byteCode.GetNumTempRegisters() * uiNumRegisters; if (uiTotalNumRegisters > m_Registers.GetCount()) { EZ_REPORT_FAILURE("Not enough registers to execute bytecode. Needs {0} but only has {1}.", uiTotalNumRegisters, m_Registers.GetCount()); return; } // Execute bytecode const ezExpressionByteCode::StorageType* pByteCode = byteCode.GetByteCode(); const ezExpressionByteCode::StorageType* pByteCodeEnd = byteCode.GetByteCodeEnd(); while (pByteCode < pByteCodeEnd) { ezExpressionByteCode::OpCode::Enum opCode = ezExpressionByteCode::GetOpCode(pByteCode); switch (opCode) { // unary case ezExpressionByteCode::OpCode::Abs_R: VMOperation1(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& x) { return x.Abs(); }); break; case ezExpressionByteCode::OpCode::Sqrt_R: VMOperation1(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& x) { return x.GetSqrt(); }); break; case ezExpressionByteCode::OpCode::Mov_R: VMOperation1(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& x) { return x; }); break; case ezExpressionByteCode::OpCode::Mov_C: VMOperation1_C(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& x) { return x; }); break; case ezExpressionByteCode::OpCode::Mov_I: VMLoadInput(pByteCode, pRegisters, uiNumRegisters, inputs, m_InputMapping); break; case ezExpressionByteCode::OpCode::Mov_O: VMStoreOutput(pByteCode, pRegisters, uiNumRegisters, outputs, m_OutputMapping); break; // binary case ezExpressionByteCode::OpCode::Add_RR: VMOperation2(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a + b; }); break; case ezExpressionByteCode::OpCode::Add_CR: VMOperation2_C(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a + b; }); break; case ezExpressionByteCode::OpCode::Sub_RR: VMOperation2(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a - b; }); break; case ezExpressionByteCode::OpCode::Sub_CR: VMOperation2_C(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a - b; }); break; case ezExpressionByteCode::OpCode::Mul_RR: VMOperation2(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a.CompMul(b); }); break; case ezExpressionByteCode::OpCode::Mul_CR: VMOperation2_C(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a.CompMul(b); }); break; case ezExpressionByteCode::OpCode::Div_RR: VMOperation2(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a.CompDiv(b); }); break; case ezExpressionByteCode::OpCode::Div_CR: VMOperation2_C(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a.CompDiv(b); }); break; case ezExpressionByteCode::OpCode::Min_RR: VMOperation2(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a.CompMin(b); }); break; case ezExpressionByteCode::OpCode::Min_CR: VMOperation2_C(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a.CompMin(b); }); break; case ezExpressionByteCode::OpCode::Max_RR: VMOperation2(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a.CompMax(b); }); break; case ezExpressionByteCode::OpCode::Max_CR: VMOperation2_C(pByteCode, pRegisters, uiNumRegisters, [](const ezSimdVec4f& a, const ezSimdVec4f& b) { return a.CompMax(b); }); break; // call case ezExpressionByteCode::OpCode::Call: VMCall(pByteCode, pRegisters, uiNumRegisters); break; default: EZ_ASSERT_NOT_IMPLEMENTED; return; } } }
void ezJSONWriter::WriteVariant(const ezVariant& value) { switch (value.GetType()) { case ezVariant::Type::Invalid: //EZ_REPORT_FAILURE("Variant of Type 'Invalid' cannot be written as JSON."); WriteNULL(); return; case ezVariant::Type::Bool: WriteBool(value.Get<bool>()); return; case ezVariant::Type::Int8: WriteInt32(value.Get<ezInt8>()); return; case ezVariant::Type::UInt8: WriteUInt32(value.Get<ezUInt8>()); return; case ezVariant::Type::Int16: WriteInt32(value.Get<ezInt16>()); return; case ezVariant::Type::UInt16: WriteUInt32(value.Get<ezUInt16>()); return; case ezVariant::Type::Int32: WriteInt32(value.Get<ezInt32>()); return; case ezVariant::Type::UInt32: WriteUInt32(value.Get<ezUInt32>()); return; case ezVariant::Type::Int64: WriteInt64(value.Get<ezInt64>()); return; case ezVariant::Type::UInt64: WriteUInt64(value.Get<ezUInt64>()); return; case ezVariant::Type::Float: WriteFloat(value.Get<float>()); return; case ezVariant::Type::Double: WriteDouble(value.Get<double>()); return; case ezVariant::Type::Color: WriteColor(value.Get<ezColor>()); return; case ezVariant::Type::Vector2: WriteVec2(value.Get<ezVec2>()); return; case ezVariant::Type::Vector3: WriteVec3(value.Get<ezVec3>()); return; case ezVariant::Type::Vector4: WriteVec4(value.Get<ezVec4>()); return; case ezVariant::Type::Quaternion: WriteQuat(value.Get<ezQuat>()); return; case ezVariant::Type::Matrix3: WriteMat3(value.Get<ezMat3>()); return; case ezVariant::Type::Matrix4: WriteMat4(value.Get<ezMat4>()); return; case ezVariant::Type::String: WriteString(value.Get<ezString>().GetData()); return; case ezVariant::Type::Time: WriteTime(value.Get<ezTime>()); return; case ezVariant::Type::Uuid: WriteUuid(value.Get<ezUuid>()); return; default: break; } EZ_REPORT_FAILURE("The Variant Type %i is not supported by ezJSONWriter::WriteVariant.", value.GetType()); }
void ezJSONWriter::WriteMat4(const ezMat4& value) { EZ_REPORT_FAILURE("The complex data type ezMat4 is not supported by this JSON writer."); }
void ezJSONWriter::WriteColor(const ezColor& value) { EZ_REPORT_FAILURE("The complex data type ezColor is not supported by this JSON writer."); }
static ezQtPropertyWidget* StandardTypeCreator(const ezRTTI* pRtti) { EZ_ASSERT_DEV(pRtti->GetTypeFlags().IsSet(ezTypeFlags::StandardType), "This function is only valid for StandardType properties, regardless of category"); if (pRtti == ezGetStaticRTTI<ezVariant>()) { return new ezQtVariantPropertyWidget(); } switch (pRtti->GetVariantType()) { case ezVariant::Type::Bool: return new ezQtPropertyEditorCheckboxWidget(); case ezVariant::Type::Time: return new ezQtPropertyEditorTimeWidget(); case ezVariant::Type::Float: case ezVariant::Type::Double: return new ezQtPropertyEditorDoubleSpinboxWidget(1); case ezVariant::Type::Vector2: return new ezQtPropertyEditorDoubleSpinboxWidget(2); case ezVariant::Type::Vector3: return new ezQtPropertyEditorDoubleSpinboxWidget(3); case ezVariant::Type::Vector4: return new ezQtPropertyEditorDoubleSpinboxWidget(4); case ezVariant::Type::Quaternion: return new ezQtPropertyEditorQuaternionWidget(); case ezVariant::Type::Int8: return new ezQtPropertyEditorIntSpinboxWidget(-127, 127); case ezVariant::Type::UInt8: return new ezQtPropertyEditorIntSpinboxWidget(0, 255); case ezVariant::Type::Int16: return new ezQtPropertyEditorIntSpinboxWidget(-32767, 32767); case ezVariant::Type::UInt16: return new ezQtPropertyEditorIntSpinboxWidget(0, 65535); case ezVariant::Type::Int32: case ezVariant::Type::Int64: return new ezQtPropertyEditorIntSpinboxWidget(-2147483645, 2147483645); case ezVariant::Type::UInt32: case ezVariant::Type::UInt64: return new ezQtPropertyEditorIntSpinboxWidget(0, 2147483645); case ezVariant::Type::String: return new ezQtPropertyEditorLineEditWidget(); case ezVariant::Type::Color: case ezVariant::Type::ColorGamma: return new ezQtPropertyEditorColorWidget(); case ezVariant::Type::Angle: return new ezQtPropertyEditorAngleWidget(); default: EZ_REPORT_FAILURE("No default property widget available for type: {0}", pRtti->GetTypeName()); return nullptr; } }
const char* GetProfileName(const char* szPlatform, ezGALShaderStage::Enum Stage) { if (ezStringUtils::IsEqual(szPlatform, "DX11_SM40_93")) { switch (Stage) { case ezGALShaderStage::VertexShader: return "vs_4_0_level_9_3"; case ezGALShaderStage::PixelShader: return "ps_4_0_level_9_3"; default: break; } } if (ezStringUtils::IsEqual(szPlatform, "DX11_SM40")) { switch (Stage) { case ezGALShaderStage::VertexShader: return "vs_4_0"; case ezGALShaderStage::GeometryShader: return "gs_4_0"; case ezGALShaderStage::PixelShader: return "ps_4_0"; case ezGALShaderStage::ComputeShader: return "cs_4_0"; default: break; } } if (ezStringUtils::IsEqual(szPlatform, "DX11_SM41")) { switch (Stage) { case ezGALShaderStage::GeometryShader: return "gs_4_0"; case ezGALShaderStage::VertexShader: return "vs_4_1"; case ezGALShaderStage::PixelShader: return "ps_4_1"; case ezGALShaderStage::ComputeShader: return "cs_4_1"; default: break; } } if (ezStringUtils::IsEqual(szPlatform, "DX11_SM50")) { switch (Stage) { case ezGALShaderStage::VertexShader: return "vs_5_0"; case ezGALShaderStage::HullShader: return "hs_5_0"; case ezGALShaderStage::DomainShader: return "ds_5_0"; case ezGALShaderStage::GeometryShader: return "gs_5_0"; case ezGALShaderStage::PixelShader: return "ps_5_0"; case ezGALShaderStage::ComputeShader: return "cs_5_0"; default: break; } } EZ_REPORT_FAILURE("Unknown Platform '{0}' or Stage {1}", szPlatform, Stage); return ""; }
void ezRTTI::SanityCheckType(ezRTTI* pType) { EZ_ASSERT_DEV(pType->GetTypeFlags().IsSet(ezTypeFlags::StandardType) + pType->GetTypeFlags().IsSet(ezTypeFlags::IsEnum) + pType->GetTypeFlags().IsSet(ezTypeFlags::Bitflags) + pType->GetTypeFlags().IsSet(ezTypeFlags::Class) == 1, "Types are mutually exclusive!"); for (auto pProp : pType->m_Properties) { const ezRTTI* pSpecificType = pProp->GetSpecificType(); EZ_ASSERT_DEBUG(IsValidIdentifierName(pProp->GetPropertyName()), "Property name is invalid: '{0}'", pProp->GetPropertyName()); // if (!IsValidIdentifierName(pProp->GetPropertyName())) //{ // ezStringBuilder s; // s.Format("RTTI: {0}\n", pProp->GetPropertyName()); // OutputDebugStringA(s.GetData()); //} if (pProp->GetCategory() != ezPropertyCategory::Function) { EZ_ASSERT_DEV(pProp->GetFlags().IsSet(ezPropertyFlags::StandardType) + pProp->GetFlags().IsSet(ezPropertyFlags::IsEnum) + pProp->GetFlags().IsSet(ezPropertyFlags::Bitflags) + pProp->GetFlags().IsSet(ezPropertyFlags::Class) <= 1, "Types are mutually exclusive!"); } switch (pProp->GetCategory()) { case ezPropertyCategory::Constant: { EZ_ASSERT_DEV(pSpecificType->GetTypeFlags().IsSet(ezTypeFlags::StandardType), "Only standard type constants are supported!"); } break; case ezPropertyCategory::Member: { EZ_ASSERT_DEV(pProp->GetFlags().IsSet(ezPropertyFlags::StandardType) == pSpecificType->GetTypeFlags().IsSet(ezTypeFlags::StandardType), "Property-Type missmatch!"); EZ_ASSERT_DEV(pProp->GetFlags().IsSet(ezPropertyFlags::IsEnum) == pSpecificType->GetTypeFlags().IsSet(ezTypeFlags::IsEnum), "Property-Type missmatch! Use EZ_BEGIN_STATIC_REFLECTED_ENUM for type and EZ_ENUM_MEMBER_PROPERTY / " "EZ_ENUM_ACCESSOR_PROPERTY for property."); EZ_ASSERT_DEV(pProp->GetFlags().IsSet(ezPropertyFlags::Bitflags) == pSpecificType->GetTypeFlags().IsSet(ezTypeFlags::Bitflags), "Property-Type missmatch! Use EZ_BEGIN_STATIC_REFLECTED_ENUM for type and EZ_BITFLAGS_MEMBER_PROPERTY / " "EZ_BITFLAGS_ACCESSOR_PROPERTY for property."); EZ_ASSERT_DEV(pProp->GetFlags().IsSet(ezPropertyFlags::Class) == pSpecificType->GetTypeFlags().IsSet(ezTypeFlags::Class), "If ezPropertyFlags::Class is set, the property type must be ezTypeFlags::Class and vise versa."); } break; case ezPropertyCategory::Array: case ezPropertyCategory::Set: case ezPropertyCategory::Map: { EZ_ASSERT_DEV(pProp->GetFlags().IsSet(ezPropertyFlags::StandardType) == pSpecificType->GetTypeFlags().IsSet(ezTypeFlags::StandardType), "Property-Type missmatch!"); EZ_ASSERT_DEV(pProp->GetFlags().IsSet(ezPropertyFlags::Class) == pSpecificType->GetTypeFlags().IsSet(ezTypeFlags::Class), "If ezPropertyFlags::Class is set, the property type must be ezTypeFlags::Class and vise versa."); } break; case ezPropertyCategory::Function: EZ_REPORT_FAILURE("Functions need to be put into the EZ_BEGIN_FUNCTIONS / EZ_END_FUNCTIONS; block."); break; } } }