blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2 values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260 values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17 values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80 values | src_encoding stringclasses 28 values | language stringclasses 1 value | is_vendor bool 1 class | is_generated bool 2 classes | length_bytes int64 8 9.86M | extension stringclasses 52 values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
58d443f465303335e97e70d2073a66abe6e91fd9 | ac566adf8ed62255012b1e5d2c7e954b06a808f3 | /folly/logging/LogStreamProcessor.h | 4edf405b52b5938e470a48e1ac276d1ad75b3b09 | [
"Apache-2.0"
] | permissive | SocialExplorerFork/folly | 09d0b7cf64b6ca93bcbdedbf186b8742b45dcd7c | aeb243f3543741375feb85c0497fae5ad0121e32 | refs/heads/master | 2020-04-05T14:55:20.595926 | 2018-05-21T13:34:06 | 2018-05-21T13:34:06 | 76,483,843 | 0 | 0 | Apache-2.0 | 2018-05-21T13:34:07 | 2016-12-14T17:57:18 | C++ | UTF-8 | C++ | false | false | 17,049 | h | /*
* Copyright 2017-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/CPortability.h>
#include <folly/Conv.h>
#include <folly/Demangle.h>
#include <folly/Format.h>
#include <folly/Portability.h>
#include <folly/logging/LogCategory.h>
#include <folly/logging/LogMessage.h>
#include <folly/logging/LogStream.h>
#include <cstdlib>
namespace folly {
/*
* Helper functions for fallback-formatting of arguments if folly::format()
* throws an exception.
*
* These are in a detail namespace so that we can include a using directive in
* order to do proper argument-dependent lookup of the correct toAppend()
* function to use.
*/
namespace detail {
/* using override */
using folly::toAppend;
template <typename Arg>
auto fallbackFormatOneArg(std::string* str, const Arg* arg, int) -> decltype(
toAppend(std::declval<Arg>(), std::declval<std::string*>()),
std::declval<void>()) {
str->push_back('(');
try {
#ifdef FOLLY_HAS_RTTI
toAppend(folly::demangle(typeid(*arg)), str);
str->append(": ");
#endif
toAppend(*arg, str);
} catch (const std::exception&) {
str->append("<error_converting_to_string>");
}
str->push_back(')');
}
template <typename Arg>
inline void fallbackFormatOneArg(std::string* str, const Arg* arg, long) {
str->push_back('(');
#ifdef FOLLY_HAS_RTTI
try {
toAppend(folly::demangle(typeid(*arg)), str);
str->append(": ");
} catch (const std::exception&) {
// Ignore the error
}
#endif
str->append("<no_string_conversion>)");
}
} // namespace detail
template <bool IsInHeaderFile>
class XlogCategoryInfo;
class XlogFileScopeInfo;
/**
* LogStreamProcessor receives a LogStream and logs it.
*
* This class is primarily intended to be used through the FB_LOG*() macros.
* Its API is designed to support these macros, and is not designed for other
* use.
*
* The operator&() method is used to trigger the logging.
* This operator is used because it has lower precedence than <<, but higher
* precedence than the ? ternary operator, allowing it to bind with the correct
* precedence in the log macro implementations.
*/
class LogStreamProcessor {
public:
enum AppendType { APPEND };
enum FormatType { FORMAT };
/**
* LogStreamProcessor constructor for use with a LOG() macro with no extra
* arguments.
*
* Note that the filename argument is not copied. The caller should ensure
* that it points to storage that will remain valid for the lifetime of the
* LogStreamProcessor. (This is always the case for the __FILE__
* preprocessor macro.)
*/
LogStreamProcessor(
const LogCategory* category,
LogLevel level,
folly::StringPiece filename,
unsigned int lineNumber,
AppendType) noexcept;
/**
* LogStreamProcessor constructor for use with a LOG() macro with arguments
* to be concatenated with folly::to<std::string>()
*
* Note that the filename argument is not copied. The caller should ensure
* that it points to storage that will remain valid for the lifetime of the
* LogStreamProcessor. (This is always the case for the __FILE__
* preprocessor macro.)
*/
template <typename... Args>
LogStreamProcessor(
const LogCategory* category,
LogLevel level,
folly::StringPiece filename,
unsigned int lineNumber,
AppendType,
Args&&... args) noexcept
: LogStreamProcessor(
category,
level,
filename,
lineNumber,
INTERNAL,
createLogString(std::forward<Args>(args)...)) {}
/**
* LogStreamProcessor constructor for use with a LOG() macro with arguments
* to be concatenated with folly::to<std::string>()
*
* Note that the filename argument is not copied. The caller should ensure
* that it points to storage that will remain valid for the lifetime of the
* LogStreamProcessor. (This is always the case for the __FILE__
* preprocessor macro.)
*/
template <typename... Args>
LogStreamProcessor(
const LogCategory* category,
LogLevel level,
folly::StringPiece filename,
unsigned int lineNumber,
FormatType,
folly::StringPiece fmt,
Args&&... args) noexcept
: LogStreamProcessor(
category,
level,
filename,
lineNumber,
INTERNAL,
formatLogString(fmt, std::forward<Args>(args)...)) {}
/*
* Versions of the above constructors for use in XLOG() statements.
*
* These are defined separately from the above constructor so that the work
* of initializing the XLOG LogCategory data is done in a separate function
* body defined in LogStreamProcessor.cpp. We intentionally want to avoid
* inlining this work at every XLOG() statement, to reduce the emitted code
* size.
*/
LogStreamProcessor(
XlogCategoryInfo<true>* categoryInfo,
LogLevel level,
folly::StringPiece categoryName,
bool isCategoryNameOverridden,
folly::StringPiece filename,
unsigned int lineNumber,
AppendType) noexcept;
template <typename... Args>
LogStreamProcessor(
XlogCategoryInfo<true>* categoryInfo,
LogLevel level,
folly::StringPiece categoryName,
bool isCategoryNameOverridden,
folly::StringPiece filename,
unsigned int lineNumber,
AppendType,
Args&&... args) noexcept
: LogStreamProcessor(
categoryInfo,
level,
categoryName,
isCategoryNameOverridden,
filename,
lineNumber,
INTERNAL,
createLogString(std::forward<Args>(args)...)) {}
template <typename... Args>
LogStreamProcessor(
XlogCategoryInfo<true>* categoryInfo,
LogLevel level,
folly::StringPiece categoryName,
bool isCategoryNameOverridden,
folly::StringPiece filename,
unsigned int lineNumber,
FormatType,
folly::StringPiece fmt,
Args&&... args) noexcept
: LogStreamProcessor(
categoryInfo,
level,
categoryName,
isCategoryNameOverridden,
filename,
lineNumber,
INTERNAL,
formatLogString(fmt, std::forward<Args>(args)...)) {}
#ifdef __INCLUDE_LEVEL__
/*
* Versions of the above constructors to use in XLOG() macros that appear in
* .cpp files. These are only used if the compiler supports the
* __INCLUDE_LEVEL__ macro, which we need to determine that the XLOG()
* statement is not in a header file.
*
* These behave identically to the XlogCategoryInfo<true> versions of the
* APIs, but slightly more optimized, and allow the XLOG() code to avoid
* storing category information at each XLOG() call site.
*/
LogStreamProcessor(
XlogFileScopeInfo* fileScopeInfo,
LogLevel level,
folly::StringPiece filename,
unsigned int lineNumber,
AppendType) noexcept;
LogStreamProcessor(
XlogFileScopeInfo* fileScopeInfo,
LogLevel level,
folly::StringPiece /* categoryName */,
bool /* isCategoryNameOverridden */,
folly::StringPiece filename,
unsigned int lineNumber,
AppendType) noexcept
: LogStreamProcessor(fileScopeInfo, level, filename, lineNumber, APPEND) {
}
template <typename... Args>
LogStreamProcessor(
XlogFileScopeInfo* fileScopeInfo,
LogLevel level,
folly::StringPiece /* categoryName */,
bool /* isCategoryNameOverridden */,
folly::StringPiece filename,
unsigned int lineNumber,
AppendType,
Args&&... args) noexcept
: LogStreamProcessor(
fileScopeInfo,
level,
filename,
lineNumber,
INTERNAL,
createLogString(std::forward<Args>(args)...)) {}
template <typename... Args>
LogStreamProcessor(
XlogFileScopeInfo* fileScopeInfo,
LogLevel level,
folly::StringPiece /* categoryName */,
bool /* isCategoryNameOverridden */,
folly::StringPiece filename,
unsigned int lineNumber,
FormatType,
folly::StringPiece fmt,
Args&&... args) noexcept
: LogStreamProcessor(
fileScopeInfo,
level,
filename,
lineNumber,
INTERNAL,
formatLogString(fmt, std::forward<Args>(args)...)) {}
#endif
~LogStreamProcessor() noexcept;
/**
* This version of operator&() is typically used when the user specifies
* log arguments using the << stream operator. The operator<<() generally
* returns a std::ostream&
*/
void operator&(std::ostream& stream) noexcept;
/**
* This version of operator&() is used when no extra arguments are specified
* with the << operator. In this case the & operator is applied directly to
* the temporary LogStream object.
*/
void operator&(LogStream&& stream) noexcept;
std::ostream& stream() noexcept {
return stream_;
}
void logNow() noexcept;
private:
enum InternalType { INTERNAL };
LogStreamProcessor(
const LogCategory* category,
LogLevel level,
folly::StringPiece filename,
unsigned int lineNumber,
InternalType,
std::string&& msg) noexcept;
LogStreamProcessor(
XlogCategoryInfo<true>* categoryInfo,
LogLevel level,
folly::StringPiece categoryName,
bool isCategoryNameOverridden,
folly::StringPiece filename,
unsigned int lineNumber,
InternalType,
std::string&& msg) noexcept;
LogStreamProcessor(
XlogFileScopeInfo* fileScopeInfo,
LogLevel level,
folly::StringPiece filename,
unsigned int lineNumber,
InternalType,
std::string&& msg) noexcept;
std::string extractMessageString(LogStream& stream) noexcept;
/**
* Construct a log message string using folly::to<std::string>()
*
* This function attempts to avoid throwing exceptions. If an error occurs
* during formatting, a message including the error details is returned
* instead. This is done to help ensure that log statements do not generate
* exceptions, but instead just log an error string when something goes wrong.
*/
template <typename... Args>
FOLLY_NOINLINE std::string createLogString(Args&&... args) noexcept {
try {
return folly::to<std::string>(std::forward<Args>(args)...);
} catch (const std::exception& ex) {
// This most likely means there was some error converting the arguments
// to strings. Handle the exception here, rather than letting it
// propagate up, since callers generally do not expect log statements to
// throw.
//
// Just log an error message letting indicating that something went wrong
// formatting the log message.
return folly::to<std::string>(
"error constructing log message: ", ex.what());
}
}
/**
* Construct a log message string using folly::sformat()
*
* This function attempts to avoid throwing exceptions. If an error occurs
* during formatting, a message including the error details is returned
* instead. This is done to help ensure that log statements do not generate
* exceptions, but instead just log an error string when something goes wrong.
*/
template <typename... Args>
FOLLY_NOINLINE std::string formatLogString(
folly::StringPiece fmt,
const Args&... args) noexcept {
try {
return folly::sformat(fmt, args...);
} catch (const std::exception& ex) {
// This most likely means that the caller had a bug in their format
// string/arguments. Handle the exception here, rather than letting it
// propagate up, since callers generally do not expect log statements to
// throw.
//
// Log the format string and as much of the arguments as we can convert,
// to aid debugging.
std::string result;
result.append("error formatting log message: ");
result.append(ex.what());
result.append("; format string: \"");
result.append(fmt.data(), fmt.size());
result.append("\", arguments: ");
fallbackFormat(&result, args...);
return result;
}
}
/**
* Helper function generate a fallback version of the arguments in case
* folly::sformat() throws an exception.
*
* This attempts to convert each argument to a string using a similar
* mechanism to folly::to<std::string>(), if supported.
*/
template <typename Arg1, typename... Args>
void
fallbackFormat(std::string* str, const Arg1& arg1, const Args&... remainder) {
detail::fallbackFormatOneArg(str, &arg1, 0);
str->append(", ");
fallbackFormat(str, remainder...);
}
template <typename Arg>
void fallbackFormat(std::string* str, const Arg& arg) {
detail::fallbackFormatOneArg(str, &arg, 0);
}
const LogCategory* const category_;
LogLevel const level_;
folly::StringPiece filename_;
unsigned int lineNumber_;
std::string message_;
LogStream stream_;
};
/**
* LogStreamVoidify() is a helper class used in the FB_LOG() and XLOG() macros.
*
* It's only purpose is to provide an & operator overload that returns void.
* This allows the log macros to expand roughly to:
*
* (logEnabled) ? (void)0
* : LogStreamVoidify{} & LogStreamProcessor{}.stream() << "msg";
*
* This enables the right hand (':') side of the ternary ? expression to have a
* void type, and allows various streaming operator expressions to be placed on
* the right hand side of the expression.
*
* Operator & is used since it has higher precedence than ?:, but lower
* precedence than <<.
*
* This class is templated on whether the log message is fatal so that the
* operator& can be declared [[noreturn]] for fatal log messages. This
* prevents the compiler from complaining about functions that do not return a
* value after a fatal log statement.
*/
template <bool Fatal>
class LogStreamVoidify {
public:
/**
* In the default (non-fatal) case, the & operator implementation is a no-op.
*
* We perform the actual logging in the LogStreamProcessor destructor. It
* feels slightly hacky to perform logging in the LogStreamProcessor
* destructor instead of here, since the LogStreamProcessor destructor is not
* evaluated until the very end of the statement. In practice log
* statements really shouldn't be in the middle of larger statements with
* other side effects, so this ordering distinction shouldn't make much
* difference.
*
* However, by keeping this function a no-op we reduce the amount of code
* generated for log statements. This function call can be completely
* eliminated by the compiler, leaving only the LogStreamProcessor destructor
* invocation, which cannot be eliminated.
*/
void operator&(std::ostream&)noexcept {}
};
template <>
class LogStreamVoidify<true> {
public:
/**
* A specialized noreturn version of operator&() for fatal log statements.
*/
[[noreturn]] void operator&(std::ostream&);
};
/**
* logDisabledHelper() is invoked in FB_LOG() and XLOG() statements if the log
* admittance check fails.
*
* This function exists solely to ensure that both sides of the log check are
* marked [[noreturn]] for fatal log messages. This allows the compiler to
* recognize that the full statement is noreturn, preventing warnings about
* missing return statements after fatal log messages.
*
* Unfortunately it does not appear possible to get the compiler to recognize
* that the disabled side of the log statement should never be reached for
* fatal messages. Even if we make the check something like
* `(isLogLevelFatal(level) || realCheck)`, where isLogLevelFatal() is
* constexpr, this is not sufficient for gcc or clang to recognize that the
* full expression is noreturn.
*
* Ideally this would just be a template function specialized on a boolean
* IsFatal parameter. Unfortunately this triggers a bug in clang, which does
* not like differing noreturn behavior for different template instantiations.
* Therefore we overload on integral_constant instead.
*
* clang-format also doesn't do a good job understanding this code and figuring
* out how to format it.
*/
// clang-format off
inline void logDisabledHelper(std::integral_constant<bool, false>) noexcept {}
[[noreturn]] void logDisabledHelper(
std::integral_constant<bool, true>) noexcept;
// clang-format on
} // namespace folly
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
8d52ca4dd64c99fb5014cc62a8be33d8850a97f0 | 72dae4abb89cbf1c8d2d4aef5e677dbd3d74cd6f | /android-11/external/libcxx/test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp | a63dc5b15f4bdf28d751803622efd6be15a4cc57 | [
"NCSA",
"MIT",
"Apache-2.0"
] | permissive | MrIkso/sdk-tools | aebb05a86e379d2883bae31f4620bcd73d832305 | 53b34cdaca0b94364446f01b5ac3455773db3029 | refs/heads/master | 2023-07-28T21:18:28.712877 | 2021-09-27T06:00:17 | 2021-09-27T06:00:17 | 309,805,035 | 7 | 3 | Apache-2.0 | 2021-09-27T06:00:18 | 2020-11-03T20:56:00 | C++ | UTF-8 | C++ | false | false | 1,937 | cpp | //===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
//
// template <class T>
// struct unwrap_ref_decay;
//
// template <class T>
// using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type;
// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
#include <functional>
#include <type_traits>
template <typename T, typename Result>
void check() {
static_assert(std::is_same_v<typename std::unwrap_ref_decay<T>::type, Result>);
static_assert(std::is_same_v<typename std::unwrap_ref_decay<T>::type, std::unwrap_ref_decay_t<T>>);
}
struct T { };
int main() {
check<T, T>();
check<T&, T>();
check<T const, T>();
check<T const&, T>();
check<T*, T*>();
check<T const*, T const*>();
check<T[3], T*>();
check<T const [3], T const*>();
check<T (), T (*)()>();
check<T (int) const, T (int) const>();
check<T (int) &, T (int) &>();
check<T (int) &&, T (int) &&>();
check<std::reference_wrapper<T>, T&>();
check<std::reference_wrapper<T>&, T&>();
check<std::reference_wrapper<T const>, T const&>();
check<std::reference_wrapper<T const>&, T const&>();
check<std::reference_wrapper<T*>, T*&>();
check<std::reference_wrapper<T*>&, T*&>();
check<std::reference_wrapper<T const*>, T const*&>();
check<std::reference_wrapper<T const*>&, T const*&>();
check<std::reference_wrapper<T[3]>, T (&)[3]>();
check<std::reference_wrapper<T[3]>&, T (&)[3]>();
check<std::reference_wrapper<T ()>, T (&)()>();
check<std::reference_wrapper<T ()>&, T (&)()>();
}
| [
"solod9362@gmail.com"
] | solod9362@gmail.com |
06327b1bf2cd1379fc1c597c94b0f331bb8657c8 | de3747ec657322a0b70ebb9c6fc83d736d62e17e | /AtCoder/abc/abc036/a.cpp | 40a66ee8618303b0f087688b6bf81e1ef21265fb | [] | no_license | pocket7878/compp | 66434391558817c965c4c7778a3b550d6004a099 | c5d04ec6c23a92f30f0455de53973499b7f62ec3 | refs/heads/master | 2021-05-01T23:45:09.987419 | 2017-01-05T04:39:05 | 2017-01-05T04:39:05 | 77,890,970 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 170 | cpp | #include <iostream>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int count = b / a;
if (b % a != 0) {
count++;
}
cout << count << endl;
}
| [
"poketo7878@gmail.com"
] | poketo7878@gmail.com |
cc269ece84e2a7f0310ff8c9b7d0c85447b6ac26 | b7f1b4df5d350e0edf55521172091c81f02f639e | /device/geolocation/public/cpp/scoped_geolocation_overrider.cc | 6e274f4eb7668fd7351372b936cf066ec4175874 | [
"BSD-3-Clause"
] | permissive | blusno1/chromium-1 | f13b84547474da4d2702341228167328d8cd3083 | 9dd22fe142b48f14765a36f69344ed4dbc289eb3 | refs/heads/master | 2023-05-17T23:50:16.605396 | 2018-01-12T19:39:49 | 2018-01-12T19:39:49 | 117,339,342 | 4 | 2 | NOASSERTION | 2020-07-17T07:35:37 | 2018-01-13T11:48:57 | null | UTF-8 | C++ | false | false | 6,776 | cc | // Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <vector>
#include "device/geolocation/public/cpp/geoposition.h"
#include "device/geolocation/public/cpp/scoped_geolocation_overrider.h"
#include "services/device/public/interfaces/constants.mojom.h"
#include "services/service_manager/public/cpp/service_context.h"
namespace device {
// This class is a fake implementation of GeolocationContext and Geolocation
// mojo interfaces for those tests which want to set an override geoposition
// value and verify their code where there are geolocation mojo calls.
class ScopedGeolocationOverrider::FakeGeolocationContext
: public mojom::GeolocationContext {
public:
explicit FakeGeolocationContext(const mojom::Geoposition& position);
~FakeGeolocationContext() override;
void UpdateLocation(const mojom::Geoposition& position);
const mojom::Geoposition& GetGeoposition() const;
void BindForOverrideService(
const std::string& interface_name,
mojo::ScopedMessagePipeHandle handle,
const service_manager::BindSourceInfo& source_info);
// mojom::GeolocationContext implementation:
void BindGeolocation(mojom::GeolocationRequest request) override;
void SetOverride(mojom::GeopositionPtr geoposition) override;
void ClearOverride() override;
private:
mojom::Geoposition position_;
mojom::GeopositionPtr override_position_;
std::vector<std::unique_ptr<FakeGeolocation>> impls_;
mojo::BindingSet<mojom::GeolocationContext> context_bindings_;
};
class ScopedGeolocationOverrider::FakeGeolocation : public mojom::Geolocation {
public:
FakeGeolocation(mojom::GeolocationRequest request,
const FakeGeolocationContext* context);
~FakeGeolocation() override;
void UpdateLocation(const mojom::Geoposition& position);
// mojom::Geolocation implementation:
void QueryNextPosition(QueryNextPositionCallback callback) override;
void SetHighAccuracy(bool high_accuracy) override;
private:
const FakeGeolocationContext* context_;
bool has_new_position_;
QueryNextPositionCallback position_callback_;
mojo::Binding<mojom::Geolocation> binding_;
};
ScopedGeolocationOverrider::ScopedGeolocationOverrider(
const mojom::Geoposition& position) {
OverrideGeolocation(position);
}
ScopedGeolocationOverrider::ScopedGeolocationOverrider(double latitude,
double longitude) {
mojom::Geoposition position;
position.latitude = latitude;
position.longitude = longitude;
position.altitude = 0.;
position.accuracy = 0.;
position.timestamp = base::Time::Now();
OverrideGeolocation(position);
}
ScopedGeolocationOverrider::~ScopedGeolocationOverrider() {
service_manager::ServiceContext::ClearGlobalBindersForTesting(
mojom::kServiceName);
}
void ScopedGeolocationOverrider::OverrideGeolocation(
const mojom::Geoposition& position) {
geolocation_context_ = std::make_unique<FakeGeolocationContext>(position);
service_manager::ServiceContext::SetGlobalBinderForTesting(
mojom::kServiceName, mojom::GeolocationContext::Name_,
base::BindRepeating(&FakeGeolocationContext::BindForOverrideService,
base::Unretained(geolocation_context_.get())));
}
void ScopedGeolocationOverrider::UpdateLocation(
const mojom::Geoposition& position) {
geolocation_context_->UpdateLocation(position);
}
void ScopedGeolocationOverrider::UpdateLocation(double latitude,
double longitude) {
mojom::Geoposition position;
position.latitude = latitude;
position.longitude = longitude;
position.altitude = 0.;
position.accuracy = 0.;
position.timestamp = base::Time::Now();
UpdateLocation(position);
}
ScopedGeolocationOverrider::FakeGeolocationContext::FakeGeolocationContext(
const mojom::Geoposition& position)
: position_(position) {
position_.valid = false;
if (ValidateGeoposition(position_))
position_.valid = true;
}
ScopedGeolocationOverrider::FakeGeolocationContext::~FakeGeolocationContext() {}
void ScopedGeolocationOverrider::FakeGeolocationContext::UpdateLocation(
const mojom::Geoposition& position) {
position_ = position;
position_.valid = false;
if (ValidateGeoposition(position_))
position_.valid = true;
for (auto& impl : impls_) {
impl->UpdateLocation(position_);
}
}
const mojom::Geoposition&
ScopedGeolocationOverrider::FakeGeolocationContext::GetGeoposition() const {
if (!override_position_.is_null())
return *override_position_;
return position_;
}
void ScopedGeolocationOverrider::FakeGeolocationContext::BindForOverrideService(
const std::string& interface_name,
mojo::ScopedMessagePipeHandle handle,
const service_manager::BindSourceInfo& source_info) {
context_bindings_.AddBinding(
this, mojom::GeolocationContextRequest(std::move(handle)));
}
void ScopedGeolocationOverrider::FakeGeolocationContext::BindGeolocation(
mojom::GeolocationRequest request) {
impls_.push_back(std::make_unique<FakeGeolocation>(std::move(request), this));
}
void ScopedGeolocationOverrider::FakeGeolocationContext::SetOverride(
mojom::GeopositionPtr geoposition) {
override_position_ = std::move(geoposition);
if (override_position_.is_null())
return;
override_position_->valid = false;
if (ValidateGeoposition(*override_position_))
override_position_->valid = true;
for (auto& impl : impls_) {
impl->UpdateLocation(*override_position_);
}
}
void ScopedGeolocationOverrider::FakeGeolocationContext::ClearOverride() {
override_position_.reset();
}
ScopedGeolocationOverrider::FakeGeolocation::FakeGeolocation(
mojom::GeolocationRequest request,
const FakeGeolocationContext* context)
: context_(context), has_new_position_(true), binding_(this) {
binding_.Bind(std::move(request));
}
ScopedGeolocationOverrider::FakeGeolocation::~FakeGeolocation() {}
void ScopedGeolocationOverrider::FakeGeolocation::UpdateLocation(
const mojom::Geoposition& position) {
has_new_position_ = true;
if (!position_callback_.is_null()) {
std::move(position_callback_).Run(position.Clone());
has_new_position_ = false;
}
}
void ScopedGeolocationOverrider::FakeGeolocation::QueryNextPosition(
QueryNextPositionCallback callback) {
// Pending callbacks might be overrided.
position_callback_ = std::move(callback);
if (has_new_position_) {
std::move(position_callback_).Run(context_->GetGeoposition().Clone());
has_new_position_ = false;
}
}
void ScopedGeolocationOverrider::FakeGeolocation::SetHighAccuracy(
bool high_accuracy) {}
} // namespace device
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
63da38b3a6885b6b5b1468e3c0aa39dc77d5781d | bcaaf0cb8153d5f519168da00da508d82262ec1c | /CardCount.cpp | 57d6a387b186f307cc722cccd78128e6d093cd62 | [] | no_license | Sarthakshah30/TopCoder-Solutions | a072743c52403e9e4a433b6fe21f6cdb2c6b3d7a | c4b2d12ed7fa7cc62c73c8a3e5a31d061383983c | refs/heads/master | 2020-09-13T10:18:32.666901 | 2018-03-05T17:32:30 | 2018-03-05T17:32:30 | 66,213,827 | 0 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 3,974 | cpp | #include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;
class CardCount {
public:
vector <string> dealHands(int p, string deck) {
vector< string > res;
for(int i = 0 ; i < p ; i++){
string temp = "";
res.push_back(temp);
}
if(deck.size() < p)
return res;
int j = 0;
for(int i = 0 ; i < deck.size() ; i++){
if(deck.size()-i < p && j==0)
return res;
res[j]=res[j]+deck[i];
j=(j+1)%p;
}
return res;
}
};
// BEGIN KAWIGIEDIT TESTING
// Generated by KawigiEdit 2.1.4 (beta) modified by pivanof
bool KawigiEdit_RunTest(int testNum, int p0, string p1, bool hasAnswer, vector <string> p2) {
cout << "Test " << testNum << ": [" << p0 << "," << "\"" << p1 << "\"";
cout << "]" << endl;
CardCount *obj;
vector <string> answer;
obj = new CardCount();
clock_t startTime = clock();
answer = obj->dealHands(p0, p1);
clock_t endTime = clock();
delete obj;
bool res;
res = true;
cout << "Time: " << double(endTime - startTime) / CLOCKS_PER_SEC << " seconds" << endl;
if (hasAnswer) {
cout << "Desired answer:" << endl;
cout << "\t" << "{";
for (int i = 0; int(p2.size()) > i; ++i) {
if (i > 0) {
cout << ",";
}
cout << "\"" << p2[i] << "\"";
}
cout << "}" << endl;
}
cout << "Your answer:" << endl;
cout << "\t" << "{";
for (int i = 0; int(answer.size()) > i; ++i) {
if (i > 0) {
cout << ",";
}
cout << "\"" << answer[i] << "\"";
}
cout << "}" << endl;
if (hasAnswer) {
if (answer.size() != p2.size()) {
res = false;
} else {
for (int i = 0; int(answer.size()) > i; ++i) {
if (answer[i] != p2[i]) {
res = false;
}
}
}
}
if (!res) {
cout << "DOESN'T MATCH!!!!" << endl;
} else if (double(endTime - startTime) / CLOCKS_PER_SEC >= 2) {
cout << "FAIL the timeout" << endl;
res = false;
} else if (hasAnswer) {
cout << "Match :-)" << endl;
} else {
cout << "OK, but is it right?" << endl;
}
cout << "" << endl;
return res;
}
int main() {
bool all_right;
all_right = true;
int p0;
string p1;
vector <string> p2;
{
// ----- test 0 -----
p0 = 6;
p1 = "012345012345012345";
string t2[] = {"000","111","222","333","444","555"};
p2.assign(t2, t2 + sizeof(t2) / sizeof(t2[0]));
all_right = KawigiEdit_RunTest(0, p0, p1, true, p2) && all_right;
// ------------------
}
{
// ----- test 1 -----
p0 = 4;
p1 = "111122223333";
string t2[] = {"123","123","123","123"};
p2.assign(t2, t2 + sizeof(t2) / sizeof(t2[0]));
all_right = KawigiEdit_RunTest(1, p0, p1, true, p2) && all_right;
// ------------------
}
{
// ----- test 2 -----
p0 = 1;
p1 = "012345012345012345";
string t2[] = {"012345012345012345"};
p2.assign(t2, t2 + sizeof(t2) / sizeof(t2[0]));
all_right = KawigiEdit_RunTest(2, p0, p1, true, p2) && all_right;
// ------------------
}
{
// ----- test 3 -----
p0 = 6;
p1 = "01234";
string t2[] = {"","","","","",""};
p2.assign(t2, t2 + sizeof(t2) / sizeof(t2[0]));
all_right = KawigiEdit_RunTest(3, p0, p1, true, p2) && all_right;
// ------------------
}
{
// ----- test 4 -----
p0 = 2;
p1 = "";
string t2[] = {"",""};
p2.assign(t2, t2 + sizeof(t2) / sizeof(t2[0]));
all_right = KawigiEdit_RunTest(4, p0, p1, true, p2) && all_right;
// ------------------
}
if (all_right) {
cout << "You're a stud (at least on the example cases)!" << endl;
} else {
cout << "Some of the test cases had errors." << endl;
}
return 0;
}
// END KAWIGIEDIT TESTING
//Powered by KawigiEdit 2.1.4 (beta) modified by pivanof!
| [
"noreply@github.com"
] | noreply@github.com |
8a87e42f97bbc0575f54d2330dc757dca0c91f8b | b47f5177f36598030d2577dec7243e1eb6b09b80 | /UVA/p476.cpp | da6015cf66de4c9937ae269ee74d758c676bf0e1 | [] | no_license | Keranos/WebProblems | c2cbdc2ea0d694afe5087b30df44f4b75d317fb7 | a9afb251607916caf602c508119fa9766c62b55d | refs/heads/master | 2022-11-03T19:28:54.542731 | 2022-10-06T13:46:27 | 2022-10-06T13:46:27 | 20,521,301 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,566 | cpp | #include <iostream>
#include <vector>
#include <iterator>
#include <string>
#include <map>
#include <math.h>
double det(double x1, double y1, double x2, double y2, double x3, double y3){
return fabs(x1*y2 - x1*y3 - y1*x2 + y1*x3 + x2*y3 - x3*y2);
}
class Point{
public:
double x, y;
};
class Rectangle{
public:
Rectangle(double nx1, double ny1, double nx2, double ny2);
bool contained(Point p);
private:
double x1, y1, x2, y2;
};
class Circle{
public :
Circle(double nx, double ny, double nr);
bool contained(Point p);
private:
double x, y, r;
};
class Triangle{
public :
Triangle(double nx1, double ny1, double nx2, double ny2, double nx3, double ny3);
bool contained(Point p);
private:
double x1, y1, x2, y2, x3, y3;
};
Rectangle::Rectangle(double nx1, double ny1, double nx2, double ny2){
this->x1 = nx1; this->y1 = ny1; this->x2 = nx2; this->y2 = ny2;
}
bool Rectangle::contained(Point p){
if(p.x > this->x1 && p.x < this->x2 && p.y < this->y1 && p.y > this->y2)
return true;
return false;
}
Circle::Circle(double nx, double ny, double nr){
this->x = nx; this->y = ny; this->r = nr;
}
bool Circle::contained(Point p){
if((this->x-p.x)*(this->x-p.x) + (this->y-p.y)*(this->y-p.y) < this->r*this->r)
return true;
return false;
}
Triangle::Triangle(double nx1, double ny1, double nx2, double ny2, double nx3, double ny3){
this->x1 = nx1; this->y1 = ny1; this->x2 = nx2; this->y2 = ny2; this->x3 = nx3; this->y3 = ny3;
}
bool Triangle::contained(Point p){
if((det(this->x1, this->y1, this->x2, this->y2, p.x, p.y) +
det(this->x1, this->y1, this->x3, this->y3, p.x, p.y) +
det(this->x2, this->y2, this->x3, this->y3, p.x, p.y) -
det(this->x1, this->y1, this->x2, this->y2, this->x3, this->y3)) < 0.0001)
return true;
return false;
}
int main(){
std::vector<Rectangle> vr;
std::vector<Circle> vc;
std::vector<Triangle> vt;
std::vector<std::string> vs;
std::string c;
double d1, d2, d3, d4, d5, d6;
while(std::cin >> c && c != "*"){
vs.push_back(c);
if(c == "r"){
std::cin >> d1 >> d2 >> d3 >> d4;
Rectangle r(d1, d2, d3, d4);
vr.push_back(r);
}
else if(c == "c"){
std::cin >> d1 >> d2 >> d3;
Circle c(d1, d2, d3);
vc.push_back(c);
}
else if(c == "t"){
std::cin >> d1 >> d2 >> d3 >> d4 >> d5 >> d6;
Triangle t(d1, d2, d3, d4, d5, d6);
vt.push_back(t);
}
}
Point p;
std::vector<std::string>::iterator siter;
int p_count = 0;
while(std::cin >> p.x >> p.y && (p.x != 9999.9 && p.y != 9999.9)){
std::vector<Rectangle>::iterator riter = vr.begin();
std::vector<Circle>::iterator citer = vc.begin();
std::vector<Triangle>::iterator titer = vt.begin();
p_count++;
bool contains, ever = false;
int f_count = 0;
for(siter = vs.begin(); siter != vs.end(); ++siter){
f_count++;
if(*siter == "r"){
contains = (*riter).contained(p);
riter++;
}
if(*siter == "c"){
contains = (*citer).contained(p);
citer++;
}
if(*siter == "t"){
contains = (*titer).contained(p);
titer++;
}
if(contains){
std::cout << "Point " << p_count << " is contained in figure " << f_count << std::endl;
ever = true;
}
}
if(!ever)
std::cout << "Point " << p_count << " is not contained in any figure" << std::endl;
}
} | [
"christopherjamessmith@gmail.com"
] | christopherjamessmith@gmail.com |
a5f9405f712c12ca9b6f5bb263e21e4d86172a4e | 1c9beebe47776e0d0a9099d7522a8c9bbc38d5e0 | /03.04.2018/Source.cpp | b3a42b5e102c51ee1e0e022cfb83098ec8a30bf5 | [] | no_license | Konstantin96/HomeWork29 | c432ffd51123da2b35388ce6969067860941a1fa | 11eea13592db2887bcea4708026e91951e94fd3b | refs/heads/master | 2020-03-09T17:57:13.207892 | 2018-04-10T11:14:44 | 2018-04-10T11:14:44 | 128,920,437 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,281 | cpp | #include <stdio.h>
#include <Windows.h>
#include <conio.h>
#include <string.h>
#include <time.h>
#include <locale.h>
#include "Header.h"
int nz;
void main()
{
FILE *file;
setlocale(LC_ALL, "Ru");
srand(time(NULL));
while (true)
{
printf("Введите номер задания: ");
scanf("%d", &nz);
if (nz == 0)
{
break;
system("exit");
}
else if (nz == 1)
{
/*1. Дана последовательность целых чисел, оканчивающаяся нулем. Записать все числа последовательности в типизированный файл*/
system("cls");
int r = 4 + rand() % 50;
if ((file = fopen("chisla.txt", "w")) == NULL)
perror("Произошла ошибка ");
else
{
for (int i = 0; i < r; i++)
{
if (i < r - 1) fprintf(file, "%d\n", 1 + rand() % 200);
else fprintf(file, "%d", 1 + rand() % 200);
}
}
fclose(file);
int razm = 0;
int *arr = NULL;
int *numb;
if ((file = fopen("chisla.txt", "r")) == NULL)
perror("Произошла ошибка ");
else
{
while (!feof(file))
{
razm++;
numb = (int*)realloc(arr, razm * sizeof(int));
if (numb != NULL)
{
arr = numb;
fscanf(file, "%d", &arr[razm - 1]);
}
}
}
fclose(file);
printf("Ñîçäàíèå íîâîãî ôàéëà è çàïèñü â íåãî ÷èñåë\n");
if ((file = fopen("chisla1.txt", "w")) == NULL)
perror("Произошла ошибка ");
else
{
for (int i = 0; i < razm; i++)
{
if (i < razm - 1) fprintf(file, "%d\n", arr[i]);
else fprintf(file, "%d", arr[i]);
}
}
fclose(file);
}
else if (nz == 2)
{
/*2. Дан файл f, компоненты которого являются целыми числами. Записать в файл g все четные числа файла f, а в файл h — все нечетные. Порядок следования чисел сохраняется*/
system("cls");
int razm = 0;
int *arr = NULL;
int *numb;
printf("Ñ÷èòûâàíèå ÷èñåë ñ ôàéëà\n");
if ((file = fopen("chisla.txt", "r")) == NULL)
perror("Произошла ошибка ");
else
{
while (!feof(file))
{
razm++;
numb = (int*)realloc(arr, razm * sizeof(int));
if (numb != NULL)
{
arr = numb;
fscanf(file, "%d", &arr[razm - 1]);
}
}
}
fclose(file);
printf("Ñîçäàíèå íîâîãî ôàéëà è çàïèñü â íåãî ÷èñåë\n");
if ((file = fopen("chisla2.txt", "w")) == NULL)
perror("Произошла ошибка ");
else
{
for (int i = 0; i < razm - 1; i++)
{
if (i < 4)
{
fprintf(file, "%d\n", arr[i]);
}
else if (i >= 4)
{
fprintf(file, "%d\n", arr[i + 1]);
}
else if (i < razm - 2)
{
fprintf(file, "%d", arr[i + 1]);
}
}
}
fclose(file);
}
else if (nz == 3)
{
/*4. Дан файл f, компоненты которого являются целыми числами. Никакая из компонент файла не равна нулю. Файл f содержит столько же отрицательных чисел, сколько и положительных. Используя вспомогательный файл h, переписать компоненты файла f в файл g так, чтобы в файле g:
a. не было двух соседних чисел с одним знаком
b. сначала шли положительные, потом отрицательные числа
c. числа шли в следующем порядке: два положитель¬ных, два отрицательных, два положительных, два отрица¬тельных и т. д. (предполагается, что число компонент в файле f делится на 4)
*/
system("cls");
int razm = 0;
char arr[80];
if ((file = fopen("text.txt", "r")) == NULL)perror("Îøèáêà îòêðûòèÿ ôàéëà: ");
else
{
while (!feof(file))
{
razm++;
fgets(arr, 80, file);
}
}
fclose(file);
printf("à. Êîëè÷åñòâî ñòðîê â ôàéëå: %d\n", razm);
char r;
razm = 0;
if ((file = fopen("text.txt", "r")) == NULL)perror("Îøèáêà îòêðûòèÿ ôàéëà: ");
else
{
while (!feof(file))
{
r = fgetc(file);
if (r != '\n')
razm++;
}
}
fclose(file);
printf("b. Êîëè÷åñòâî ñèìâîëîâ â ôàéëå: %d\n", razm);
printf("c. Êîëè÷åñòâî ñèìâîëîâ â ñòðîêàõ:\n");
if ((file = fopen("text.txt", "r")) == NULL)perror("Îøèáêà îòêðûòèÿ ôàéëà: ");
else
{
int s = 0, count;
while (!feof(file))
{
arr[0] = '\0';
fgets(arr, 80, file);
s++;
count = strlen(arr);
printf("%d - %d\n", s, count - 1);
}
}
fclose(file);
}
else if (nz == 4)
{
/*9.В существующем типизированном файле, элементами которого являются отдельные слова, изменить на заданное слово
a. s-е слово
b. последнее слово
*/
system("cls");
char arr[80];
char sim;
if ((file = fopen("text.txt", "r")) == NULL)
perror("Îøèáêà îòêðûòèÿ ôàéëà: ");
else
{
while (!feof(file))
{
fscanf(file, "%s", arr);
printf("%s", arr);
sim = fgetc(file);
if (sim != 'ÿ')
printf("%c", sim);
}
}
fclose(file);
printf("\n");
char wordR[20];
printf("a.\n");
int s, sch = 0;
printf("Ââåäèòå íîìåð ñëîâà êîòîðîå íàäî çàìåíèòü "); scanf("%d", &s);
printf("Ââåäèòå ñëîâî íà êîòîðîå íàäî çàìåíèòü "); scanf("%s", &wordR);
if ((file = fopen("text.txt", "r")) == NULL)perror("Îøèáêà îòêðûòèÿ ôàéëà: ");
else
{
while (!feof(file))
{
fscanf(file, "%s", arr);
sch++;
if (sch == s)
printf("%s", wordR);
else
printf("%s", arr);
sim = fgetc(file);
if (sim != 'ÿ')
printf("%c", sim);
}
}
fclose(file);
printf("\n");
printf("b.\n");
s = 27, sch = 0;
printf("Ââåäèòå ñëîâî íà êîòîðîå íàäî çàìåíèòü ïîñëåäíåå ñëîâî "); scanf("%s", &wordR);
if ((file = fopen("text.txt", "r")) == NULL)perror("Îøèáêà îòêðûòèÿ ôàéëà: ");
else
{
while (!feof(file))
{
fscanf(file, "%s", arr);
sch++;
if (sch == s)
printf("%s", wordR);
else
printf("%s", arr);
sim = fgetc(file);
if (sim != 'ÿ')
printf("%c", sim);
}
}
fclose(file);
printf("\n");
}
else if (nz == 5)
{
/*10.Элементами типизированного файла являются отдельные слова. Изменить все его элементы на другие слова (их значения вводятся с клавиатуры).*/
system("cls");
char arr[80];
char sim;
if ((file = fopen("text.txt", "r")) == NULL)perror("Îøèáêà îòêðûòèÿ ôàéëà: ");
else
{
while (!feof(file))
{
fscanf(file, "%s", arr);
printf("%s", arr);
sim = fgetc(file);
if (sim != 'ÿ')
printf("%c", sim);
}
}
fclose(file);
printf("\n");
char word[20];
char wordR[20];
int ln;
printf("Ââåäèòå ñëîâî êîòîðîå íàäî çàìåíèòü "); scanf("%s", &word);
printf("Ââåäèòå ñëîâî íà êîòîðîå íàäî çàìåíèòü "); scanf("%s", &wordR);
if ((file = fopen("text.txt", "r")) == NULL)perror("Îøèáêà îòêðûòèÿ ôàéëà: ");
else
{
while (!feof(file))
{
fscanf(file, "%s", arr);
ln = strlen(arr);
if (strcmp(arr, word) == 0)
printf("%s", wordR);
else
printf("%s", arr);
sim = fgetc(file);
if (sim != 'ÿ')
printf("%c", sim);
}
}
fclose(file);
printf("\n");
}
else if (nz == 6)
{
/*11. Имеется типизированный файл, элементами которого являются отдельные буквы, составляющие последовательность орпцессор. */
char *simb;
int i = 1;
simb = (char*)malloc(i * sizeof(char));
simb[0] = '\0';
if ((file = fopen("1.txt", "r")) == NULL)perror("Îøèáêà îòêðûòèÿ ôàéëà: ");
else
{
while (!feof(file))
{
simb[i - 1] = fgetc(file);
i++;
simb = (char*)realloc(simb, i * sizeof(char));
}
}
fclose(file);
simb[i - 2] = '\0';
char t;
t = simb[0];
simb[0] = simb[2];
simb[2] = t;
printf("\n%s\n", simb);
if ((file = fopen("2.txt", "w")) == NULL)
perror("Îøèáêà îòêðûòèÿ ôàéëà: ");
else
{
fprintf(file, "%s", simb);
}
fclose(file);
}
else
{
printf("Такого задания нету! \n");
}
}
} | [
"34293528+Konstantin96@users.noreply.github.com"
] | 34293528+Konstantin96@users.noreply.github.com |
ff2c98aa5f67bb5c8a6f059d5c42ea1d8445633e | 77e02752a43ab091f49cd214198559d895786093 | /page_rank/timestamp.hpp | 05dda3a231f0e68b97b9c98ee30bce172a16ff6b | [] | no_license | mkhatiri/Projet_US_test | 1be603b3ccc4a370f4bd45fb794f6ffd43953442 | 85aa92f998f2a73f01e11caf5e061797719f60d2 | refs/heads/master | 2021-05-12T06:48:03.403118 | 2018-01-12T10:10:35 | 2018-01-12T10:10:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,444 | hpp |
// This file is part of SPart, Spatially Located Workload Partitioner.
// Copyright (C) 2011, The Ohio State University
// SPart developed by Erdeniz O. Bas, Erik Saule and Umit V. Catalyurek
// For questions, comments, suggestions, bugs please send e-mail to:
// Umit V. Catalyurek catalyurek.1@osu.edu
// SPart is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later
// version.
// SPart is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for more details.
// You should have received a copy of the GNU General Public License
// along with SPart; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
// As a special exception, if other files instantiate templates or use
// macros or inline functions from this file, or you compile this file
// and link it with other works to produce a work based on this file,
// this file does not by itself cause the resulting work to be covered by
// the GNU General Public License. However the source code for this file
// must still be made available in accordance with section (3) of the GNU
// General Public License.
// This exception does not invalidate any other reasons why a work based
// on this file might be covered by the GNU General Public License.
// The full text of the GPL license version 2 is available in "gpl.txt".
#ifndef TIMESTAMP_ERIK_H__
#define TIMESTAMP_ERIK_H__
#include <sys/time.h>
#include <iostream>
#include <stdio.h>
namespace util{class timestamp;}
static std::ostream& operator<< (std::ostream&, const util::timestamp&);
namespace util
{
/**
* @brief allow to keep track of time with a precision of a
* microseconds.
*
* The default constructors obtains the time with
* gettimeofday(2). Timestamps can be added or substracted and
* pushed to streams such as std::cout. It keeps track of time using
* integers so as not to lose precision. Typical use of the class
* are: \code
* timestamp t1;
* foo();
* timestamp t2;
* std::cout<<"foo() took "<<t2-t1<<" seconds"<<std::endl;
* \endcode
* or
* \code
* timestamp acc (0,0);
* while (some_condition()){
* do_stuff();
* timestamp t1;
* do_important_stuff();
* timestamp t2;
* acc += t2-t1;
* do_more_stuff();
* }
* std::cout<<"do_important_stuff() took "<<acc<<" seconds"<<std::endl;
* \endcode
**/
class timestamp
{
int seconds;
int microseconds; //< 1000000
/** @brief fix overflow after an add or a substract.
*
* Notice it only fix the overflow of one unit.
**/
void fixme()
{
if (microseconds < 0)
{
seconds --;
microseconds += 1000000;
}
else if (microseconds > 1000000)
{
seconds ++;
microseconds -= 1000000;
}
}
public:
/// obtains time using gettimeofday(2)
timestamp()
{
struct timeval tv;
gettimeofday (&tv, NULL); //should check return code
seconds = tv.tv_sec;
microseconds = tv.tv_usec;
}
/// provides time in seconds and microseconds
timestamp(int s, int us)
:seconds(s), microseconds(us)
{}
timestamp(const timestamp& m)
:seconds(m.seconds), microseconds(m.microseconds)
{
}
timestamp operator+ (const timestamp& b)
{
timestamp ret (this->seconds + b.seconds,
this->microseconds+b.microseconds);
ret.fixme();
return ret;
}
timestamp operator- (const timestamp& b)
{
timestamp ret (this->seconds - b.seconds,
this->microseconds - b.microseconds);
ret.fixme();
return ret;
}
operator double () const
{
double ret = this->seconds + this->microseconds/1000000.;
return ret;
}
const timestamp& operator += (const timestamp& b)
{
this->seconds += b.seconds;
this->microseconds += b.microseconds;
this->fixme();
return *this;
}
const timestamp& operator -= (const timestamp& b)
{
this->seconds -= b.seconds;
this->microseconds -= b.microseconds;
this->fixme();
return *this;
}
friend std::ostream& ::operator<< (std::ostream&, const util::timestamp&);
timestamp operator/ (const int i) const
{
timestamp t (this->seconds / i, (1000000*(this->seconds%i)+this->microseconds)/i);
t.fixme();
return t;
}
const timestamp& operator/= (const int i)
{
//do not invert the following two lines!
this->microseconds = (1000000*(this->seconds%i)+this->microseconds)/i;
this->seconds = this->seconds/i;
this->fixme(); //I don't think that fixem() is necessary
return *this;
}
void print ()
{
printf ("%d.%06d",seconds, microseconds);
}
void to_c_str(char* out, int size)
{
snprintf (out, size, "%d.%06d",seconds, microseconds);
}
};
}
static std::ostream& operator<< (std::ostream& out, const util::timestamp& t)
{
char microsecval[7];
out<<t.seconds<<'.';
sprintf(microsecval, "%06d", t.microseconds);
out<<microsecval;
return out;
}
#endif
| [
"khatiri.med@gmail.com"
] | khatiri.med@gmail.com |
5395c3c88b892e833598614d9ad9090e26cc6917 | 007867b4937f52de7746f79124ef104b2d183f5a | /统计问题/RMQ/HDU 6098 Inversion.cpp | 4a9021099d51a91d3d7995b30c739a7d642dedb2 | [] | no_license | WhereIsHeroFrom/Algorithm | 84dcee3174dbcd9e996442f07627a96c46f6c74a | 6bf620d6219770db60b40d151eecd686955ab723 | refs/heads/master | 2023-08-05T14:05:48.385791 | 2021-10-06T00:21:39 | 2021-10-06T00:21:39 | 306,805,686 | 16 | 4 | null | null | null | null | GB18030 | C++ | false | false | 2,073 | cpp | #include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
// RMQ 区间最小值询问
const int MAXM = 18;
const int MAXN = (1<<MAXM)+1;
// typedef __int64 ValueType;
// typedef double ValueType;
typedef int ValueType;
int lg2K[MAXN];
int RMQ_MinIndex(ValueType A[], int l, int r) {
return A[r] < A[l] ? r : l;
}
// f[i][j] = opt(f[i-1][j], f[i-1][j + 2^{i-1}]);
void RMQ_Init(ValueType A[], int ALen, int(*f)[MAXN]) {
int i, j, k = 0;
for (i = 1; i <= ALen; i++) {
lg2K[i] = k - 1;
if ((1 << k) == i) k++;
}
for (i = 0; i < MAXM; i++) {
for (j = 1; j + (1<<i) - 1 <= ALen; j++) {
if (i == 0) {
f[i][j] = j;
}
else {
f[i][j] = RMQ_MinIndex(A, f[i-1][j], f[i-1][j + (1 << (i - 1))]);
}
}
}
}
/*
设区间长度为2^k，则X表示的区间为[a, a + 2^k)，Y表示的区间为(b - 2^k, b]，
则需要满足一个条件就是X的右端点必须大于等于Y的左端点-1，即 a+2^k-1 >= b-2^k，
则2^(k+1) >= (b-a+1), 两边取对数（以2为底），得 k+1 >= lg(b-a+1)，则k >= lg(b-a+1) - 1。
k只要需要取最小的满足条件的整数即可( lg(x)代表以2为底x的对数 )。
*/
int RMQ_Query(ValueType A[], int(*f)[MAXN], int a, int b) {
if (a == b) {
return a;
}
else if (a > b) {
a = a^b, b = a^b, a = a^b;
}
int k = lg2K[b - a + 1];
return RMQ_MinIndex(A, f[k][a], f[k][b - (1 << k) + 1]);
}
ValueType fMax[MAXM][MAXN];
ValueType a[MAXN];
int main() {
int t;
int i;
int n;
scanf("%d", &t);
while(t--) {
scanf("%d", &n);
for(i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i] = -a[i];
}
RMQ_Init(a, n, fMax);
for(i = 2; i <= n; ++i) {
int idx = RMQ_Query(a, fMax, 1, i-1);
int nowl = i + 1, nowr = i + i - 1;
while(nowl <= n) {
if(nowr > n) {
nowr = n;
}
idx = RMQ_MinIndex(a, idx, RMQ_Query(a, fMax, nowl, nowr) );
nowl += i;
nowr += i;
}
int ans = - a[idx];
if(i > 2) {
printf(" ");
}
printf("%d", ans);
}
puts("");
}
return 0;
}
/*
122
9
8 5 4 3 7 2 9 10 7
*/
| [
"menjitianya2007@163.com"
] | menjitianya2007@163.com |
5872259fd10fd2d013cda1d453d675fd5cb86874 | cf81ff11851591b3ded1004604a7a3ce6927f79c | /exe/processSub/processSub.cpp | f1c69b00eceb62f1dc7fb9bac27e3331f611fee8 | [] | no_license | laurentiuvieriu/FaceAnalysisLite | a9617fa94017ee641953d94e39a4c9919d685350 | a535b5d5e0ffba577c87242e38c09441c24ab5f5 | refs/heads/master | 2021-01-23T00:14:55.495518 | 2017-03-09T12:23:17 | 2017-03-09T12:23:17 | 85,706,132 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 23,684 | cpp | // this program implements one of the system subscribers, that takes camera frames from the publisher specified by -pubPort
// and performs face analysis (head pose estimation, AU recognition, pain and emotional valence estimation, etc).
// the subscriber is, in turn, publisher to external subscribers (the publishing address is specified by -subPort)
// usage: <executable> -pubPort <publishing_port> -subPort <subscriber_port> -settings <path_to_settings.ini>settings.ini -debugMode <debug_mode (0, 1, default = 1)>
// Author: RLV (UNITN)
// last update: 20/02/17 ..
// Local includes
#include "LandmarkCoreIncludes.h"
#include <Face_utils.h>
#include <FaceAnalyser.h>
#include <GazeEstimation.h>
#include "ferLocalFunctions.h"
#include "utilsProcessSub.h"
#include <zmq.hpp>
#include "zhelpers.hpp"
#include <boost/circular_buffer.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
using namespace fer;
void get_double_from_arguments(vector<string> &arguments, string key, double& keyval) {
bool* valid = new bool[arguments.size()];
valid[0] = true;
for (size_t i = 0; i < arguments.size(); ++i) {
if (arguments[i].compare(key) == 0) {
stringstream data(arguments[i + 1]);
data >> keyval;
break;
}
}
}
void read_arguments(vector<string> &arguments, string &pubPort, string &subPort, string &settingsFile, bool &debugMode) {
bool* valid = new bool[arguments.size()];
valid[0] = true;
for (size_t i = 0; i < arguments.size(); ++i) {
if (arguments[i].compare("-pubPort") == 0) {
pubPort = arguments[i+ 1];
valid[i] = false;
valid[i + 1] = false;
i++;
}
if (arguments[i].compare("-subPort") == 0) {
subPort = arguments[i + 1];
valid[i] = false;
valid[i + 1] = false;
i++;
}
if (arguments[i].compare("-settings") == 0) {
settingsFile = arguments[i + 1];
valid[i] = false;
valid[i + 1] = false;
i++;
}
if (arguments[i].compare("-debugMode") == 0) {
stringstream data(arguments[i + 1]);
data >> debugMode;
valid[i] = false;
valid[i + 1] = false;
i++;
}
}
for (int i = (int)arguments.size() - 1; i >= 0; --i)
{
if (!valid[i])
{
arguments.erase(arguments.begin() + i);
}
}
}
unsigned long GetCurrentTimeInMilliseconds()
{
boost::posix_time::ptime time = boost::posix_time::microsec_clock::local_time();
boost::posix_time::time_duration duration( time.time_of_day() );
return duration.total_milliseconds();
}
int main(int argc, char** argv)
{
vector<string> argumentsComm = get_arguments(argc, argv);
string pubPort = "";
string subPort = "";
string settings_file = "";
bool debugMode = false;
read_arguments(argumentsComm, pubPort, subPort, settings_file, debugMode);
if (strcmp(pubPort.c_str(), "") == 1){
pubPort = "tcp://*:5556";
cout << "processSub.cpp -> main: Unspecified publisher port (-pubPort <port address>), using default value: " << pubPort << endl;
}
if (strcmp(subPort.c_str(), "") == 1){
subPort = "tcp://*:6000";
cout << "processSub.cpp -> main: Unspecified subscriber port (-subPort <port address>), using default value: " << subPort << endl;
}
if (strcmp(settings_file.c_str(), "") == 1){
cout << "processSub.cpp -> main: Unspecified settings file (-settings <settings file>), aborting... " << endl;
return 0;
}
vector<string> arguments = get_arguments_from_file(settings_file);
vector<string> input_pubId, input_cam, input_files, depth_directories, output_files, tracked_videos_output;
LandmarkDetector::FaceModelParameters det_parameters(arguments);
det_parameters.track_gaze = true;
// Get the input output file parameters
// Indicates that rotation should be with respect to camera or world coordinates
bool use_world_coordinates = false;
string output_codec; //not used but should
LandmarkDetector::get_video_input_output_params(input_pubId, input_cam, input_files, depth_directories, output_files, tracked_videos_output, use_world_coordinates, output_codec, arguments);
bool video_input = false;
bool verbose = true;
bool images_as_video = true;
// Grab camera parameters, if they are not defined (approximate values will be used)
float fx = 0, fy = 0, cx = 0, cy = 0;
int d = 0;
// Get camera parameters
LandmarkDetector::get_camera_params(d, fx, fy, cx, cy, arguments);
// If cx (optical axis centre) is undefined will use the image size/2 as an estimate
bool cx_undefined = false;
bool fx_undefined = false;
if (cx == 0 || cy == 0)
{
cx_undefined = true;
}
if (fx == 0 || fy == 0)
{
fx_undefined = true;
}
// The modules that are being used for tracking
cout << "Initializing face model ...";
LandmarkDetector::CLNF face_model(det_parameters.model_location);
cout << "done" << endl;
vector<string> output_similarity_align;
vector<string> output_hog_align_files;
double sim_scale = 0.7;
int sim_size = 112;
bool grayscale = false;
bool video_output = false;
bool dynamic = true; // Indicates if a dynamic AU model should be used (dynamic is useful if the video is long enough to include neutral expressions)
int num_hog_rows;
int num_hog_cols;
// output parameters
bool output_2D_landmarks = false;
bool output_3D_landmarks = false;
bool output_model_params = false;
bool output_frame_idx = false;
bool output_timestamp = false;
bool output_confidence = false;
bool output_success = false;
bool output_head_position = false;
bool output_head_pose = false;
bool output_AUs_reg = false;
bool output_AUs_class = false;
bool output_gaze = false;
bool output_pain_level = false;
bool output_valence = false;
bool output_arousal = false;
get_output_feature_params(output_similarity_align, output_hog_align_files, sim_scale, sim_size, grayscale, verbose, dynamic,
output_2D_landmarks, output_3D_landmarks, output_model_params, output_frame_idx, output_timestamp,
output_confidence, output_success, output_head_position, output_head_pose, output_AUs_reg, output_AUs_class,
output_gaze, output_pain_level, output_valence, output_arousal, arguments);
// Used for image masking
// if output_pain_level is on, then load the pain models too ...
paramList params_pain;
const string featDataRoot_pain = get_key_from_arguments(arguments, "-rootDir_pain");
RV_readParamList(featDataRoot_pain, ¶ms_pain);
vector<randomTree> forest_pain;
const string treesDir_pain = featDataRoot_pain+ "trees/";
forest_pain = RV_readForest(treesDir_pain, params_pain);
paramList params_valence;
const string featDataRoot_valence = get_key_from_arguments(arguments, "-rootDir_valence");
RV_readParamList(featDataRoot_valence, ¶ms_valence);
vector<randomTree> forest_valence;
const string treesDir_valence = featDataRoot_valence+ "trees/";
forest_valence = RV_readForest(treesDir_valence, params_valence);
string tri_loc;
if(boost::filesystem::exists(path("model/tris_68_full.txt"))){
tri_loc = "model/tris_68_full.txt";
}
else{
path loc = path(arguments[0]).parent_path() / "model/tris_68_full.txt";
tri_loc = loc.string();
if(!exists(loc)){
cout << "Can't find triangulation files, exiting" << endl;
return 1;
}
}
// Will warp to scaled mean shape
cv::Mat_<double> similarity_normalised_shape = face_model.pdm.mean_shape * sim_scale;
// Discard the z component
similarity_normalised_shape = similarity_normalised_shape(cv::Rect(0, 0, 1, 2*similarity_normalised_shape.rows/3)).clone();
// If multiple video files are tracked, use this to indicate if we are done
bool done = false;
int f_n = 0;
int curr_img = -1;
string au_loc;
string au_loc_local;
if (dynamic){
au_loc_local = "AU_predictors/AU_all_best.txt";
}
else{
au_loc_local = "AU_predictors/AU_all_static.txt";
}
if(boost::filesystem::exists(path(au_loc_local))){
au_loc = au_loc_local;
}
else{
path loc = path(arguments[0]).parent_path() / au_loc_local;
if(exists(loc)){
au_loc = loc.string();
}
else{
cout << "Can't find AU prediction files, exiting ..." << endl;
return 1;
}
}
// Creating a face analyser that will be used for AU extraction
FaceAnalysis::FaceAnalyser face_analyser(vector<cv::Vec3d>(), 0.7, 112, 112, au_loc, tri_loc);
// ----------------------------------------------------------------------
// finally subscribe to the pub Id ...
zmq::context_t context (1);
std::cout << "Collecting updates from server…\n" << std::endl;
zmq::socket_t subscriber (context, ZMQ_SUB);
uint64_t RCVBUF = 500000;
subscriber.setsockopt(ZMQ_RCVBUF, &RCVBUF, sizeof(RCVBUF));
uint64_t HWM = 1;
subscriber.setsockopt(ZMQ_HWM, &HWM, sizeof(HWM));
subscriber.setsockopt(ZMQ_SUBSCRIBE, "", 0);
subscriber.connect(pubPort.c_str());
bool pub_sub_flag = true;
// end of subscribing to publisher
// ----------------------------------------------------------------------
// now launch a publisher port for broadcasting results
zmq::context_t contextPub (1);
std::cout << "Creating publisher context \n" << std::endl;
zmq::socket_t publisher (contextPub, ZMQ_PUB);
// uint64_t SNDBUF = 50000;
// publisher.setsockopt(ZMQ_SNDBUF, &SNDBUF, sizeof(SNDBUF));
// publisher.setsockopt(ZMQ_HWM, &HWM, sizeof(HWM));
publisher.bind(subPort.c_str());
// end of creating context for the publisher part
// ----------------------------------------------------------------------
boost::circular_buffer<double> painVec(30);
boost::circular_buffer<double> valenceVec(30);
boost::circular_buffer<double> arousalVec(30);
vector<double> valenceMap = {-0.81, -0.68, -0.41, -0.12, -0.92, 0.0, 0.9};
vector<double> arousalMap = {-0.4, 0.49, 0.79, 0.79, 0.02, 0.00, 0.17};
// end of initialization ...
while(!done)
{
zmq::message_t message;
Mat captured_image(480, 640, CV_8SC3);
int total_frames = -1;
int reported_completion = 0;
double fps_vid_in = -1.0;
curr_img++;
subscriber.recv(&message);
memcpy(captured_image.data, message.data(), message.size());
captured_image.convertTo(captured_image, CV_8U);
// cap >> captured_image;
if( captured_image.empty() ) break;
// If optical centers are not defined just use center of image
if(cx_undefined){
cx = captured_image.cols / 2.0f;
cy = captured_image.rows / 2.0f;
}
// Use a rough guess-timate of focal length
if (fx_undefined){
fx = 500 * (captured_image.cols / 640.0);
fy = 500 * (captured_image.rows / 480.0);
fx = (fx + fy) / 2.0;
fy = fx;
}
// Creating output files
std::ofstream output_file;
if (!output_files.empty()){
output_file.open(output_files[f_n], ios_base::out);
prepareOutputFile(&output_file, output_2D_landmarks, output_3D_landmarks, output_model_params, output_frame_idx,
output_timestamp, output_confidence, output_success, output_head_position, output_head_pose, output_AUs_reg, output_AUs_class,
output_gaze, output_pain_level, output_valence, output_arousal, face_model.pdm.NumberOfPoints(), face_model.pdm.NumberOfModes(),
face_analyser.GetAUClassNames(), face_analyser.GetAURegNames());
}
// Saving the HOG features
std::ofstream hog_output_file;
if(!output_hog_align_files.empty())
{
hog_output_file.open(output_hog_align_files[f_n], ios_base::out | ios_base::binary);
}
// saving the videos
cv::VideoWriter writerFace;
if(!tracked_videos_output.empty())
{
try
{
writerFace.open(tracked_videos_output[f_n], CV_FOURCC(output_codec[0],output_codec[1],output_codec[2],output_codec[3]), 30, captured_image.size(), true);
}
catch(cv::Exception e)
{
WARN_STREAM( "Could not open VideoWriter, OUTPUT FILE WILL NOT BE WRITTEN. Currently using codec " << output_codec << ", try using an other one (-oc option)");
}
}
int frame_count = 0;
// This is useful for a second pass run (if want AU predictions)
vector<cv::Vec6d> params_global_video;
vector<bool> successes_video;
vector<cv::Mat_<double>> params_local_video;
vector<cv::Mat_<double>> detected_landmarks_video;
// Use for timestamping if using a webcam
int64 t_initial = cv::getTickCount();
bool visualise_hog = verbose;
// Timestamp in seconds of current processing
double time_stamp = 0;
INFO_STREAM( "Starting tracking");
while(!captured_image.empty())
{
// system time in ms
unsigned long sys_time = GetCurrentTimeInMilliseconds();
// Grab the timestamp first
if (video_input)
{
time_stamp = (double)frame_count * (1.0 / fps_vid_in);
}
else
{
// if loading images assume 30fps
time_stamp = (double)frame_count * (1.0 / 30.0);
}
// Reading the images
cv::Mat_<uchar> grayscale_image;
if(captured_image.channels() == 3)
{
cvtColor(captured_image, grayscale_image, CV_BGR2GRAY);
}
else
{
grayscale_image = captured_image.clone();
}
// The actual facial landmark detection / tracking
bool detection_success;
if(video_input || images_as_video)
{
detection_success = LandmarkDetector::DetectLandmarksInVideo(grayscale_image, face_model, det_parameters);
}
else
{
detection_success = LandmarkDetector::DetectLandmarksInImage(grayscale_image, face_model, det_parameters);
}
// Gaze tracking, absolute gaze direction
cv::Point3f gazeDirection0(0, 0, -1);
cv::Point3f gazeDirection1(0, 0, -1);
if (det_parameters.track_gaze && detection_success && face_model.eye_model)
{
FaceAnalysis::EstimateGaze(face_model, gazeDirection0, fx, fy, cx, cy, true);
FaceAnalysis::EstimateGaze(face_model, gazeDirection1, fx, fy, cx, cy, false);
}
// Do face alignment
cv::Mat sim_warped_img;
cv::Mat_<double> hog_descriptor;
// But only if needed in output
if(!output_similarity_align.empty() || hog_output_file.is_open() || output_AUs_reg || output_AUs_class || output_pain_level)
{
face_analyser.AddNextFrame(captured_image, face_model, time_stamp, false, !det_parameters.quiet_mode);
face_analyser.GetLatestAlignedFace(sim_warped_img);
// if(!det_parameters.quiet_mode)
// {
// cv::imshow("sim_warp", sim_warped_img);
// }
if(hog_output_file.is_open())
{
FaceAnalysis::Extract_FHOG_descriptor(hog_descriptor, sim_warped_img, num_hog_rows, num_hog_cols);
if(visualise_hog && !det_parameters.quiet_mode)
{
cv::Mat_<double> hog_descriptor_vis;
FaceAnalysis::Visualise_FHOG(hog_descriptor, num_hog_rows, num_hog_cols, hog_descriptor_vis);
cv::imshow("hog", hog_descriptor_vis);
}
}
}
// Work out the pose of the head from the tracked model
cv::Vec6d pose_estimate;
if(use_world_coordinates)
{
pose_estimate = LandmarkDetector::GetCorrectedPoseWorld(face_model, fx, fy, cx, cy);
}
else
{
pose_estimate = LandmarkDetector::GetCorrectedPoseCamera(face_model, fx, fy, cx, cy);
}
if(hog_output_file.is_open())
{
output_HOG_frame(&hog_output_file, detection_success, hog_descriptor, num_hog_rows, num_hog_cols);
}
// Write the similarity normalised output
if(!output_similarity_align.empty())
{
if (sim_warped_img.channels() == 3 && grayscale)
{
cvtColor(sim_warped_img, sim_warped_img, CV_BGR2GRAY);
}
char name[100];
// output the frame number
std::sprintf(name, "frame_det_%06d.bmp", frame_count);
// Construct the output filename
boost::filesystem::path slash("/");
std::string preferredSlash = slash.make_preferred().string();
string out_file = output_similarity_align[f_n] + preferredSlash + string(name);
bool write_success = imwrite(out_file, sim_warped_img);
if (!write_success)
{
cout << "Could not output similarity aligned image image" << endl;
return 1;
}
}
// run here the pain detector
double instant_painLevel = 0;
double instant_valence = 0;
double instant_arousal = 0;
int argMax_expression = 0;
if (output_pain_level) {
instant_painLevel = get_pain_level_from_face(face_analyser, forest_pain, params_pain);
}
// vector<double> valenceMap = {-0.81, -0.68, -0.41, -0.12, -0.92, 0.0, 0.9};
// vector<double> arousalMap = {-0.4, 0.49, 0.79, 0.79, 0.02, 0.00, 0.17};
vector<double> valence_pred;
valence_pred = get_expression_from_face(face_analyser, forest_valence, params_valence);
argMax_expression = std::distance(valence_pred.begin(), std::max_element(valence_pred.begin(), valence_pred.end()));
instant_valence = valenceMap[argMax_expression];
instant_arousal = (arousalMap[argMax_expression]+ 1)/2;
painVec.push_back(instant_painLevel);
double pain_sum = std::accumulate(painVec.begin(), painVec.end(), 0.0);
double painLevel = pain_sum/painVec.size();
valenceVec.push_back(instant_valence);
double valence_sum = std::accumulate(valenceVec.begin(), valenceVec.end(), 0.0);
double valenceLevel = valence_sum/valenceVec.size();
arousalVec.push_back(instant_arousal);
double arousal_sum = std::accumulate(arousalVec.begin(), arousalVec.end(), 0.0);
double arousalLevel = arousal_sum/arousalVec.size();
cv::Vec6d pose_estimate_to_draw = LandmarkDetector::GetCorrectedPoseWorld(face_model, fx, fy, cx, cy);
double hp_tilt = (double) pose_estimate_to_draw[3] * (-1) * 180 / CV_PI;
s_sendmore(publisher, "headTilt");
s_send(publisher, boost::lexical_cast<std::string>(hp_tilt));
double hp_yaw = (double) pose_estimate_to_draw[4] * 180 / CV_PI;
s_sendmore(publisher, "headYaw");
s_send(publisher, boost::lexical_cast<std::string>(hp_yaw));
double hp_roll = (double) pose_estimate_to_draw[5] * 180 / CV_PI;
s_sendmore(publisher, "headRoll");
s_send(publisher, boost::lexical_cast<std::string>(hp_roll));
s_sendmore(publisher, "valenceLevel");
s_send(publisher, boost::lexical_cast<std::string>(valenceLevel));
s_sendmore(publisher, "arousalLevel");
s_send(publisher, boost::lexical_cast<std::string>(arousalLevel));
s_sendmore(publisher, "painLevel");
s_send(publisher, boost::lexical_cast<std::string>(painLevel));
s_sendmore(publisher, "sys_time");
s_send(publisher, boost::lexical_cast<std::string>(sys_time));
// Visualising the tracker
if (debugMode) {
visualise_tracking(captured_image, face_model, det_parameters, gazeDirection0, gazeDirection1,
frame_count, fx, fy, cx, cy,
face_analyser, painLevel, valenceLevel, arousalLevel, output_head_pose, output_AUs_class);
}
// Output the landmarks, pose, gaze, parameters and AUs
if (output_file.is_open()) {
outputAllFeatures(&output_file, output_2D_landmarks, output_3D_landmarks, output_model_params,
output_frame_idx,
output_timestamp, output_confidence, output_success, output_head_position,
output_head_pose, output_AUs_reg, output_AUs_class,
output_gaze, output_pain_level, output_valence, output_arousal, face_model,
frame_count, (double)sys_time, detection_success, gazeDirection0, gazeDirection1,
pose_estimate, fx, fy, cx, cy, painLevel, valenceLevel, arousalLevel, face_analyser);
}
// output the tracked video
if(!tracked_videos_output.empty())
{
writerFace << captured_image;
}
if(pub_sub_flag)
{
subscriber.recv(&message);
memcpy(captured_image.data, message.data(), message.size());
}
else
{
captured_image = cv::Mat();
}
// detect key presses
char character_press = cv::waitKey(1);
// restart the tracker
if(character_press == 'r')
{
face_model.Reset();
}
if (character_press=='d')
{
captured_image = cv::Mat();
done = true;
}
// quit the application
if(character_press=='q')
{
return(0);
}
// Update the frame count
frame_count++;
}
if (!output_files.empty()) {
output_file.close();
}
// if(output_files.size() > 0 && (output_AUs_reg || output_AUs_class))
// {
// cout << "Postprocessing the Action Unit predictions" << endl;
// post_process_output_file(face_analyser, output_files[f_n], dynamic);
// }
// Reset the models for the next video
face_analyser.Reset();
face_model.Reset();
frame_count = 0;
curr_img = -1;
}
return 0;
}
| [
"laurentiuvieriu@gmail.com"
] | laurentiuvieriu@gmail.com |
8a68d33971a6ae6bc13a2d655a34fde39dd7a58c | 4e697961037240ad357a5ddd6a1365f588a4969c | /external/Clipper2Lib/src/clipper.rectclip.cpp | e142331ccdca105359a714400e410328b5cec178 | [] | no_license | szakeetm/shared_sources | 7dc94ba25b5828cf1993f4ea4790e88e8a067ca1 | 1fba669e8b3c6ba0cd89c1c2084a235dfd02ee74 | refs/heads/master | 2023-09-05T12:05:45.179173 | 2023-08-18T13:54:30 | 2023-08-18T13:54:30 | 140,718,435 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 26,684 | cpp | /*******************************************************************************
* Author : Angus Johnson *
* Date : 14 February 2023 *
* Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2023 *
* Purpose : FAST rectangular clipping *
* License : http://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/
#include <cmath>
#include "clipper.h"
#include "clipper.rectclip.h"
namespace Clipper2Lib {
//------------------------------------------------------------------------------
// Miscellaneous methods
//------------------------------------------------------------------------------
inline bool Path1ContainsPath2(const Path64& path1, const Path64& path2)
{
int io_count = 0;
// precondition: no (significant) overlap
for (const Point64& pt : path2)
{
PointInPolygonResult pip = PointInPolygon(pt, path1);
switch (pip)
{
case PointInPolygonResult::IsOutside: ++io_count; break;
case PointInPolygonResult::IsInside: --io_count; break;
default: continue;
}
if (std::abs(io_count) > 1) break;
}
return io_count <= 0;
}
inline bool GetLocation(const Rect64& rec,
const Point64& pt, Location& loc)
{
if (pt.x == rec.left && pt.y >= rec.top && pt.y <= rec.bottom)
{
loc = Location::Left;
return false;
}
else if (pt.x == rec.right && pt.y >= rec.top && pt.y <= rec.bottom)
{
loc = Location::Right;
return false;
}
else if (pt.y == rec.top && pt.x >= rec.left && pt.x <= rec.right)
{
loc = Location::Top;
return false;
}
else if (pt.y == rec.bottom && pt.x >= rec.left && pt.x <= rec.right)
{
loc = Location::Bottom;
return false;
}
else if (pt.x < rec.left) loc = Location::Left;
else if (pt.x > rec.right) loc = Location::Right;
else if (pt.y < rec.top) loc = Location::Top;
else if (pt.y > rec.bottom) loc = Location::Bottom;
else loc = Location::Inside;
return true;
}
inline bool GetIntersection(const Path64& rectPath,
const Point64& p, const Point64& p2, Location& loc, Point64& ip)
{
// gets the intersection closest to 'p'
// when Result = false, loc will remain unchanged
switch (loc)
{
case Location::Left:
if (SegmentsIntersect(p, p2, rectPath[0], rectPath[3], true))
GetIntersectPoint(p, p2, rectPath[0], rectPath[3], ip);
else if (p.y < rectPath[0].y &&
SegmentsIntersect(p, p2, rectPath[0], rectPath[1], true))
{
GetIntersectPoint(p, p2, rectPath[0], rectPath[1], ip);
loc = Location::Top;
}
else if (SegmentsIntersect(p, p2, rectPath[2], rectPath[3], true))
{
GetIntersectPoint(p, p2, rectPath[2], rectPath[3], ip);
loc = Location::Bottom;
}
else return false;
break;
case Location::Top:
if (SegmentsIntersect(p, p2, rectPath[0], rectPath[1], true))
GetIntersectPoint(p, p2, rectPath[0], rectPath[1], ip);
else if (p.x < rectPath[0].x &&
SegmentsIntersect(p, p2, rectPath[0], rectPath[3], true))
{
GetIntersectPoint(p, p2, rectPath[0], rectPath[3], ip);
loc = Location::Left;
}
else if (p.x > rectPath[1].x &&
SegmentsIntersect(p, p2, rectPath[1], rectPath[2], true))
{
GetIntersectPoint(p, p2, rectPath[1], rectPath[2], ip);
loc = Location::Right;
}
else return false;
break;
case Location::Right:
if (SegmentsIntersect(p, p2, rectPath[1], rectPath[2], true))
GetIntersectPoint(p, p2, rectPath[1], rectPath[2], ip);
else if (p.y < rectPath[0].y &&
SegmentsIntersect(p, p2, rectPath[0], rectPath[1], true))
{
GetIntersectPoint(p, p2, rectPath[0], rectPath[1], ip);
loc = Location::Top;
}
else if (SegmentsIntersect(p, p2, rectPath[2], rectPath[3], true))
{
GetIntersectPoint(p, p2, rectPath[2], rectPath[3], ip);
loc = Location::Bottom;
}
else return false;
break;
case Location::Bottom:
if (SegmentsIntersect(p, p2, rectPath[2], rectPath[3], true))
GetIntersectPoint(p, p2, rectPath[2], rectPath[3], ip);
else if (p.x < rectPath[3].x &&
SegmentsIntersect(p, p2, rectPath[0], rectPath[3], true))
{
GetIntersectPoint(p, p2, rectPath[0], rectPath[3], ip);
loc = Location::Left;
}
else if (p.x > rectPath[2].x &&
SegmentsIntersect(p, p2, rectPath[1], rectPath[2], true))
{
GetIntersectPoint(p, p2, rectPath[1], rectPath[2], ip);
loc = Location::Right;
}
else return false;
break;
default: // loc == rInside
if (SegmentsIntersect(p, p2, rectPath[0], rectPath[3], true))
{
GetIntersectPoint(p, p2, rectPath[0], rectPath[3], ip);
loc = Location::Left;
}
else if (SegmentsIntersect(p, p2, rectPath[0], rectPath[1], true))
{
GetIntersectPoint(p, p2, rectPath[0], rectPath[1], ip);
loc = Location::Top;
}
else if (SegmentsIntersect(p, p2, rectPath[1], rectPath[2], true))
{
GetIntersectPoint(p, p2, rectPath[1], rectPath[2], ip);
loc = Location::Right;
}
else if (SegmentsIntersect(p, p2, rectPath[2], rectPath[3], true))
{
GetIntersectPoint(p, p2, rectPath[2], rectPath[3], ip);
loc = Location::Bottom;
}
else return false;
break;
}
return true;
}
inline Location GetAdjacentLocation(Location loc, bool isClockwise)
{
int delta = (isClockwise) ? 1 : 3;
return static_cast<Location>((static_cast<int>(loc) + delta) % 4);
}
inline bool HeadingClockwise(Location prev, Location curr)
{
return (static_cast<int>(prev) + 1) % 4 == static_cast<int>(curr);
}
inline bool AreOpposites(Location prev, Location curr)
{
return abs(static_cast<int>(prev) - static_cast<int>(curr)) == 2;
}
inline bool IsClockwise(Location prev, Location curr,
const Point64& prev_pt, const Point64& curr_pt, const Point64& rect_mp)
{
if (AreOpposites(prev, curr))
return CrossProduct(prev_pt, rect_mp, curr_pt) < 0;
else
return HeadingClockwise(prev, curr);
}
inline OutPt2* UnlinkOp(OutPt2* op)
{
if (op->next == op) return nullptr;
op->prev->next = op->next;
op->next->prev = op->prev;
return op->next;
}
inline OutPt2* UnlinkOpBack(OutPt2* op)
{
if (op->next == op) return nullptr;
op->prev->next = op->next;
op->next->prev = op->prev;
return op->prev;
}
inline uint32_t GetEdgesForPt(const Point64& pt, const Rect64& rec)
{
uint32_t result = 0;
if (pt.x == rec.left) result = 1;
else if (pt.x == rec.right) result = 4;
if (pt.y == rec.top) result += 2;
else if (pt.y == rec.bottom) result += 8;
return result;
}
inline bool IsHeadingClockwise(const Point64& pt1, const Point64& pt2, int edgeIdx)
{
switch (edgeIdx)
{
case 0: return pt2.y < pt1.y;
case 1: return pt2.x > pt1.x;
case 2: return pt2.y > pt1.y;
default: return pt2.x < pt1.x;
}
}
inline bool HasHorzOverlap(const Point64& left1, const Point64& right1,
const Point64& left2, const Point64& right2)
{
return (left1.x < right2.x) && (right1.x > left2.x);
}
inline bool HasVertOverlap(const Point64& top1, const Point64& bottom1,
const Point64& top2, const Point64& bottom2)
{
return (top1.y < bottom2.y) && (bottom1.y > top2.y);
}
inline void AddToEdge(OutPt2List& edge, OutPt2* op)
{
if (op->edge) return;
op->edge = &edge;
edge.push_back(op);
}
inline void UncoupleEdge(OutPt2* op)
{
if (!op->edge) return;
for (size_t i = 0; i < op->edge->size(); ++i)
{
OutPt2* op2 = (*op->edge)[i];
if (op2 == op)
{
(*op->edge)[i] = nullptr;
break;
}
}
op->edge = nullptr;
}
inline void SetNewOwner(OutPt2* op, size_t new_idx)
{
op->owner_idx = new_idx;
OutPt2* op2 = op->next;
while (op2 != op)
{
op2->owner_idx = new_idx;
op2 = op2->next;
}
}
//----------------------------------------------------------------------------
// RectClip64
//----------------------------------------------------------------------------
OutPt2* RectClip::Add(Point64 pt, bool start_new)
{
// this method is only called by InternalExecute.
// Later splitting & rejoining won't create additional op's,
// though they will change the (non-storage) results_ count.
int curr_idx = static_cast<int>(results_.size()) - 1;
OutPt2* result;
if (curr_idx < 0 || start_new)
{
result = &op_container_.emplace_back(OutPt2());
result->pt = pt;
result->next = result;
result->prev = result;
results_.push_back(result);
}
else
{
OutPt2* prevOp = results_[curr_idx];
if (prevOp->pt == pt) return prevOp;
result = &op_container_.emplace_back(OutPt2());
result->owner_idx = curr_idx;
result->pt = pt;
result->next = prevOp->next;
prevOp->next->prev = result;
prevOp->next = result;
result->prev = prevOp;
results_[curr_idx] = result;
}
return result;
}
void RectClip::AddCorner(Location prev, Location curr)
{
if (HeadingClockwise(prev, curr))
Add(rect_as_path_[static_cast<int>(prev)]);
else
Add(rect_as_path_[static_cast<int>(curr)]);
}
void RectClip::AddCorner(Location& loc, bool isClockwise)
{
if (isClockwise)
{
Add(rect_as_path_[static_cast<int>(loc)]);
loc = GetAdjacentLocation(loc, true);
}
else
{
loc = GetAdjacentLocation(loc, false);
Add(rect_as_path_[static_cast<int>(loc)]);
}
}
void RectClip::GetNextLocation(const Path64& path,
Location& loc, int& i, int highI)
{
switch (loc)
{
case Location::Left:
while (i <= highI && path[i].x <= rect_.left) ++i;
if (i > highI) break;
else if (path[i].x >= rect_.right) loc = Location::Right;
else if (path[i].y <= rect_.top) loc = Location::Top;
else if (path[i].y >= rect_.bottom) loc = Location::Bottom;
else loc = Location::Inside;
break;
case Location::Top:
while (i <= highI && path[i].y <= rect_.top) ++i;
if (i > highI) break;
else if (path[i].y >= rect_.bottom) loc = Location::Bottom;
else if (path[i].x <= rect_.left) loc = Location::Left;
else if (path[i].x >= rect_.right) loc = Location::Right;
else loc = Location::Inside;
break;
case Location::Right:
while (i <= highI && path[i].x >= rect_.right) ++i;
if (i > highI) break;
else if (path[i].x <= rect_.left) loc = Location::Left;
else if (path[i].y <= rect_.top) loc = Location::Top;
else if (path[i].y >= rect_.bottom) loc = Location::Bottom;
else loc = Location::Inside;
break;
case Location::Bottom:
while (i <= highI && path[i].y >= rect_.bottom) ++i;
if (i > highI) break;
else if (path[i].y <= rect_.top) loc = Location::Top;
else if (path[i].x <= rect_.left) loc = Location::Left;
else if (path[i].x >= rect_.right) loc = Location::Right;
else loc = Location::Inside;
break;
case Location::Inside:
while (i <= highI)
{
if (path[i].x < rect_.left) loc = Location::Left;
else if (path[i].x > rect_.right) loc = Location::Right;
else if (path[i].y > rect_.bottom) loc = Location::Bottom;
else if (path[i].y < rect_.top) loc = Location::Top;
else { Add(path[i]); ++i; continue; }
break; //inner loop
}
break;
} //switch
}
void RectClip::ExecuteInternal(const Path64& path)
{
int i = 0, highI = static_cast<int>(path.size()) - 1;
Location prev = Location::Inside, loc;
Location crossing_loc = Location::Inside;
Location first_cross_ = Location::Inside;
if (!GetLocation(rect_, path[highI], loc))
{
i = highI - 1;
while (i >= 0 && !GetLocation(rect_, path[i], prev)) --i;
if (i < 0)
{
// all of path must be inside fRect
for (const auto& pt : path) Add(pt);
return;
}
if (prev == Location::Inside) loc = Location::Inside;
i = 0;
}
Location startingLoc = loc;
///////////////////////////////////////////////////
while (i <= highI)
{
prev = loc;
Location crossing_prev = crossing_loc;
GetNextLocation(path, loc, i, highI);
if (i > highI) break;
Point64 ip, ip2;
Point64 prev_pt = (i) ?
path[static_cast<size_t>(i - 1)] :
path[highI];
crossing_loc = loc;
if (!GetIntersection(rect_as_path_,
path[i], prev_pt, crossing_loc, ip))
{
// ie remaining outside
if (crossing_prev == Location::Inside)
{
bool isClockw = IsClockwise(prev, loc, prev_pt, path[i], rect_mp_);
do {
start_locs_.push_back(prev);
prev = GetAdjacentLocation(prev, isClockw);
} while (prev != loc);
crossing_loc = crossing_prev; // still not crossed
}
else if (prev != Location::Inside && prev != loc)
{
bool isClockw = IsClockwise(prev, loc, prev_pt, path[i], rect_mp_);
do {
AddCorner(prev, isClockw);
} while (prev != loc);
}
++i;
continue;
}
////////////////////////////////////////////////////
// we must be crossing the rect boundary to get here
////////////////////////////////////////////////////
if (loc == Location::Inside) // path must be entering rect
{
if (first_cross_ == Location::Inside)
{
first_cross_ = crossing_loc;
start_locs_.push_back(prev);
}
else if (prev != crossing_loc)
{
bool isClockw = IsClockwise(prev, crossing_loc, prev_pt, path[i], rect_mp_);
do {
AddCorner(prev, isClockw);
} while (prev != crossing_loc);
}
}
else if (prev != Location::Inside)
{
// passing right through rect. 'ip' here will be the second
// intersect pt but we'll also need the first intersect pt (ip2)
loc = prev;
GetIntersection(rect_as_path_, prev_pt, path[i], loc, ip2);
if (crossing_prev != Location::Inside)
AddCorner(crossing_prev, loc);
if (first_cross_ == Location::Inside)
{
first_cross_ = loc;
start_locs_.push_back(prev);
}
loc = crossing_loc;
Add(ip2);
if (ip == ip2)
{
// it's very likely that path[i] is on rect
GetLocation(rect_, path[i], loc);
AddCorner(crossing_loc, loc);
crossing_loc = loc;
continue;
}
}
else // path must be exiting rect
{
loc = crossing_loc;
if (first_cross_ == Location::Inside)
first_cross_ = crossing_loc;
}
Add(ip);
} //while i <= highI
///////////////////////////////////////////////////
if (first_cross_ == Location::Inside)
{
// path never intersects
if (startingLoc != Location::Inside)
{
// path is outside rect
// but being outside, it still may not contain rect
if (path_bounds_.Contains(rect_) &&
Path1ContainsPath2(path, rect_as_path_))
{
// yep, the path does fully contain rect
// so add rect to the solution
for (size_t j = 0; j < 4; ++j)
{
Add(rect_as_path_[j]);
// we may well need to do some splitting later, so
AddToEdge(edges_[j * 2], results_[0]);
}
}
}
}
else if (loc != Location::Inside &&
(loc != first_cross_ || start_locs_.size() > 2))
{
if (start_locs_.size() > 0)
{
prev = loc;
for (auto loc2 : start_locs_)
{
if (prev == loc2) continue;
AddCorner(prev, HeadingClockwise(prev, loc2));
prev = loc2;
}
loc = prev;
}
if (loc != first_cross_)
AddCorner(loc, HeadingClockwise(loc, first_cross_));
}
}
void RectClip::CheckEdges()
{
for (size_t i = 0; i < results_.size(); ++i)
{
OutPt2* op = results_[i];
if (!op) continue;
OutPt2* op2 = op;
do
{
if (!CrossProduct(op2->prev->pt,
op2->pt, op2->next->pt))
{
if (op2 == op)
{
op2 = UnlinkOpBack(op2);
if (!op2) break;
op = op2->prev;
}
else
{
op2 = UnlinkOpBack(op2);
if (!op2) break;
}
}
else
op2 = op2->next;
} while (op2 != op);
if (!op2)
{
results_[i] = nullptr;
continue;
}
results_[i] = op; // safety first
uint32_t edgeSet1 = GetEdgesForPt(op->prev->pt, rect_);
op2 = op;
do
{
uint32_t edgeSet2 = GetEdgesForPt(op2->pt, rect_);
if (edgeSet2 && !op2->edge)
{
uint32_t combinedSet = (edgeSet1 & edgeSet2);
for (int j = 0; j < 4; ++j)
{
if (combinedSet & (1 << j))
{
if (IsHeadingClockwise(op2->prev->pt, op2->pt, j))
AddToEdge(edges_[j * 2], op2);
else
AddToEdge(edges_[j * 2 + 1], op2);
}
}
}
edgeSet1 = edgeSet2;
op2 = op2->next;
} while (op2 != op);
}
}
void RectClip::TidyEdges(int idx, OutPt2List& cw, OutPt2List& ccw)
{
if (ccw.empty()) return;
bool isHorz = ((idx == 1) || (idx == 3));
bool cwIsTowardLarger = ((idx == 1) || (idx == 2));
size_t i = 0, j = 0;
OutPt2* p1, * p2, * p1a, * p2a, * op, * op2;
while (i < cw.size())
{
p1 = cw[i];
if (!p1 || p1->next == p1->prev)
{
cw[i++]->edge = nullptr;
j = 0;
continue;
}
size_t jLim = ccw.size();
while (j < jLim &&
(!ccw[j] || ccw[j]->next == ccw[j]->prev)) ++j;
if (j == jLim)
{
++i;
j = 0;
continue;
}
if (cwIsTowardLarger)
{
// p1 >>>> p1a;
// p2 <<<< p2a;
p1 = cw[i]->prev;
p1a = cw[i];
p2 = ccw[j];
p2a = ccw[j]->prev;
}
else
{
// p1 <<<< p1a;
// p2 >>>> p2a;
p1 = cw[i];
p1a = cw[i]->prev;
p2 = ccw[j]->prev;
p2a = ccw[j];
}
if ((isHorz && !HasHorzOverlap(p1->pt, p1a->pt, p2->pt, p2a->pt)) ||
(!isHorz && !HasVertOverlap(p1->pt, p1a->pt, p2->pt, p2a->pt)))
{
++j;
continue;
}
// to get here we're either splitting or rejoining
bool isRejoining = cw[i]->owner_idx != ccw[j]->owner_idx;
if (isRejoining)
{
results_[p2->owner_idx] = nullptr;
SetNewOwner(p2, p1->owner_idx);
}
// do the split or re-join
if (cwIsTowardLarger)
{
// p1 >> | >> p1a;
// p2 << | << p2a;
p1->next = p2;
p2->prev = p1;
p1a->prev = p2a;
p2a->next = p1a;
}
else
{
// p1 << | << p1a;
// p2 >> | >> p2a;
p1->prev = p2;
p2->next = p1;
p1a->next = p2a;
p2a->prev = p1a;
}
if (!isRejoining)
{
size_t new_idx = results_.size();
results_.push_back(p1a);
SetNewOwner(p1a, new_idx);
}
if (cwIsTowardLarger)
{
op = p2;
op2 = p1a;
}
else
{
op = p1;
op2 = p2a;
}
results_[op->owner_idx] = op;
results_[op2->owner_idx] = op2;
// and now lots of work to get ready for the next loop
bool opIsLarger, op2IsLarger;
if (isHorz) // X
{
opIsLarger = op->pt.x > op->prev->pt.x;
op2IsLarger = op2->pt.x > op2->prev->pt.x;
}
else // Y
{
opIsLarger = op->pt.y > op->prev->pt.y;
op2IsLarger = op2->pt.y > op2->prev->pt.y;
}
if ((op->next == op->prev) ||
(op->pt == op->prev->pt))
{
if (op2IsLarger == cwIsTowardLarger)
{
cw[i] = op2;
ccw[j++] = nullptr;
}
else
{
ccw[j] = op2;
cw[i++] = nullptr;
}
}
else if ((op2->next == op2->prev) ||
(op2->pt == op2->prev->pt))
{
if (opIsLarger == cwIsTowardLarger)
{
cw[i] = op;
ccw[j++] = nullptr;
}
else
{
ccw[j] = op;
cw[i++] = nullptr;
}
}
else if (opIsLarger == op2IsLarger)
{
if (opIsLarger == cwIsTowardLarger)
{
cw[i] = op;
UncoupleEdge(op2);
AddToEdge(cw, op2);
ccw[j++] = nullptr;
}
else
{
cw[i++] = nullptr;
ccw[j] = op2;
UncoupleEdge(op);
AddToEdge(ccw, op);
j = 0;
}
}
else
{
if (opIsLarger == cwIsTowardLarger)
cw[i] = op;
else
ccw[j] = op;
if (op2IsLarger == cwIsTowardLarger)
cw[i] = op2;
else
ccw[j] = op2;
}
}
}
Path64 RectClip::GetPath(OutPt2*& op)
{
if (!op || op->next == op->prev) return Path64();
OutPt2* op2 = op->next;
while (op2 && op2 != op)
{
if (CrossProduct(op2->prev->pt,
op2->pt, op2->next->pt) == 0)
{
op = op2->prev;
op2 = UnlinkOp(op2);
}
else
op2 = op2->next;
}
op = op2; // needed for op cleanup
if (!op2) return Path64();
Path64 result;
result.push_back(op->pt);
op2 = op->next;
while (op2 != op)
{
result.push_back(op2->pt);
op2 = op2->next;
}
return result;
}
Paths64 RectClip::Execute(const Paths64& paths, bool convex_only)
{
Paths64 result;
if (rect_.IsEmpty()) return result;
for (const auto& path : paths)
{
if (path.size() < 3) continue;
path_bounds_ = GetBounds(path);
if (!rect_.Intersects(path_bounds_))
continue; // the path must be completely outside rect_
else if (rect_.Contains(path_bounds_))
{
// the path must be completely inside rect_
result.push_back(path);
continue;
}
ExecuteInternal(path);
if (!convex_only)
{
CheckEdges();
for (int i = 0; i < 4; ++i)
TidyEdges(i, edges_[i * 2], edges_[i * 2 + 1]);
}
for (OutPt2*& op : results_)
{
Path64 tmp = GetPath(op);
if (!tmp.empty())
result.emplace_back(tmp);
}
//clean up after every loop
op_container_ = std::deque<OutPt2>();
results_.clear();
for (OutPt2List edge : edges_) edge.clear();
start_locs_.clear();
}
return result;
}
//------------------------------------------------------------------------------
// RectClipLines
//------------------------------------------------------------------------------
Paths64 RectClipLines::Execute(const Paths64& paths)
{
Paths64 result;
if (rect_.IsEmpty()) return result;
for (const auto& path : paths)
{
if (path.size() < 2) continue;
Rect64 pathrec = GetBounds(path);
if (!rect_.Intersects(pathrec)) continue;
ExecuteInternal(path);
for (OutPt2*& op : results_)
{
Path64 tmp = GetPath(op);
if (!tmp.empty())
result.emplace_back(tmp);
}
results_.clear();
op_container_ = std::deque<OutPt2>();
start_locs_.clear();
}
return result;
}
void RectClipLines::ExecuteInternal(const Path64& path)
{
if (rect_.IsEmpty() || path.size() < 2) return;
results_.clear();
op_container_ = std::deque<OutPt2>();
start_locs_.clear();
int i = 1, highI = static_cast<int>(path.size()) - 1;
Location prev = Location::Inside, loc;
Location crossing_loc;
if (!GetLocation(rect_, path[0], loc))
{
while (i <= highI && !GetLocation(rect_, path[i], prev)) ++i;
if (i > highI)
{
// all of path must be inside fRect
for (const auto& pt : path) Add(pt);
return;
}
if (prev == Location::Inside) loc = Location::Inside;
i = 1;
}
if (loc == Location::Inside) Add(path[0]);
///////////////////////////////////////////////////
while (i <= highI)
{
prev = loc;
GetNextLocation(path, loc, i, highI);
if (i > highI) break;
Point64 ip, ip2;
Point64 prev_pt = path[static_cast<size_t>(i - 1)];
crossing_loc = loc;
if (!GetIntersection(rect_as_path_,
path[i], prev_pt, crossing_loc, ip))
{
// ie remaining outside
++i;
continue;
}
////////////////////////////////////////////////////
// we must be crossing the rect boundary to get here
////////////////////////////////////////////////////
if (loc == Location::Inside) // path must be entering rect
{
Add(ip, true);
}
else if (prev != Location::Inside)
{
// passing right through rect. 'ip' here will be the second
// intersect pt but we'll also need the first intersect pt (ip2)
crossing_loc = prev;
GetIntersection(rect_as_path_,
prev_pt, path[i], crossing_loc, ip2);
Add(ip2, true);
Add(ip);
}
else // path must be exiting rect
{
Add(ip);
}
} //while i <= highI
///////////////////////////////////////////////////
}
Path64 RectClipLines::GetPath(OutPt2*& op)
{
Path64 result;
if (!op || op == op->next) return result;
op = op->next; // starting at path beginning
result.push_back(op->pt);
OutPt2 *op2 = op->next;
while (op2 != op)
{
result.push_back(op2->pt);
op2 = op2->next;
}
return result;
}
} // namespace
| [
"marton.ady@cern.ch"
] | marton.ady@cern.ch |
97132d0da195c98b767dae5add0e2181e72d4c80 | b49616f91836142e8c6197357b58886f40d91a03 | /thrust/detail/backend/cuda/detail/get_set_operation_splitter_ranks.inl | e45e3fb7b48575153c8cea1e6e32a3c6756b83d6 | [] | no_license | gregorburger/solver-playground | 1b7a5f40892920bf779f4aadfd8842bef7857e15 | 618767338f9ab1698d094290a361792a2f3e4797 | refs/heads/master | 2021-01-01T18:38:03.611575 | 2011-11-24T13:26:30 | 2011-11-24T13:26:30 | 2,835,689 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,433 | inl | /*
* Copyright 2008-2011 NVIDIA Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <thrust/detail/backend/cuda/detail/get_set_operation_splitter_ranks.h>
#include <thrust/iterator/counting_iterator.h>
#include <thrust/iterator/permutation_iterator.h>
#include <thrust/iterator/transform_iterator.h>
#include <thrust/iterator/iterator_traits.h>
#include <thrust/tuple.h>
#include <thrust/detail/backend/generic/scalar/select.h>
#include <thrust/binary_search.h>
#include <thrust/iterator/iterator_traits.h>
namespace thrust
{
namespace detail
{
namespace backend
{
namespace cuda
{
namespace detail
{
namespace get_set_operation_splitter_ranks_detail
{
template<typename T>
struct mult_by
: thrust::unary_function<T,T>
{
T _value;
mult_by(const T& v):_value(v){}
__host__ __device__
T operator()(const T& v) const
{
return _value * v;
}
};
template<typename Iterator1, typename Iterator2, typename Compare>
struct select_functor
{
Iterator1 first1, last1;
Iterator2 first2, last2;
Compare comp;
select_functor(Iterator1 f1, Iterator1 l1,
Iterator2 f2, Iterator2 l2,
Compare c)
: first1(f1), last1(l1), first2(f2), last2(l2), comp(c)
{}
// satisfy AdaptableUnaryFunction
typedef typename thrust::iterator_value<Iterator1>::type result_type;
typedef typename thrust::iterator_difference<Iterator1>::type argument_type;
__host__ __device__
result_type operator()(argument_type k)
{
typedef typename thrust::iterator_value<Iterator1>::type value_type;
return thrust::detail::backend::generic::scalar::select(first1, last1, first2, last2, k, comp);
}
}; // end select_functor
template<typename Iterator1, typename Iterator2, typename Compare>
class merge_iterator
{
typedef thrust::counting_iterator<typename thrust::iterator_difference<Iterator1>::type> counting_iterator;
typedef select_functor<Iterator1,Iterator2,Compare> function;
public:
typedef thrust::transform_iterator<function, counting_iterator> type;
}; // end merge_iterator
template<typename Iterator1, typename Iterator2, typename Compare>
typename merge_iterator<Iterator1,Iterator2,Compare>::type
make_merge_iterator(Iterator1 first1, Iterator1 last1,
Iterator2 first2, Iterator2 last2,
Compare comp)
{
typedef typename thrust::iterator_difference<Iterator1>::type difference;
difference zero = 0;
select_functor<Iterator1,Iterator2,Compare> f(first1,last1,first2,last2,comp);
return thrust::make_transform_iterator(thrust::make_counting_iterator<difference>(zero),
f);
} // end make_merge_iterator()
template<typename Integer>
class leapfrog_iterator
{
typedef thrust::counting_iterator<Integer> counter;
public:
typedef thrust::transform_iterator<mult_by<Integer>, counter> type;
}; // end leapfrog_iterator
template<typename Integer>
typename leapfrog_iterator<Integer>::type
make_leapfrog_iterator(Integer init, Integer leap_size)
{
return thrust::make_transform_iterator(thrust::make_counting_iterator<Integer>(init),
mult_by<Integer>(leap_size));
} // end make_leapfrog_iterator()
template<typename RandomAccessIterator>
class splitter_iterator
{
typedef typename thrust::iterator_difference<RandomAccessIterator>::type difference;
typedef typename leapfrog_iterator<difference>::type leapfrog_iterator;
public:
typedef thrust::permutation_iterator<RandomAccessIterator, leapfrog_iterator> type;
}; // end splitter_iterator
template<typename RandomAccessIterator, typename Size>
typename splitter_iterator<RandomAccessIterator>::type
make_splitter_iterator(RandomAccessIterator iter, Size split_size)
{
typedef typename thrust::iterator_difference<RandomAccessIterator>::type difference;
return thrust::make_permutation_iterator(iter, make_leapfrog_iterator<difference>(0, split_size));
} // end make_splitter_iterator()
} // end get_set_operation_splitter_ranks_detail
template<typename RandomAccessIterator1,
typename RandomAccessIterator2,
typename RandomAccessIterator3,
typename RandomAccessIterator4,
typename Compare,
typename Size1,
typename Size2,
typename Size3>
void get_set_operation_splitter_ranks(RandomAccessIterator1 first1,
RandomAccessIterator1 last1,
RandomAccessIterator2 first2,
RandomAccessIterator2 last2,
RandomAccessIterator3 splitter_ranks1,
RandomAccessIterator4 splitter_ranks2,
Compare comp,
Size1 partition_size,
Size2 num_splitters_from_range1,
Size3 num_splitters_from_range2)
{
using namespace get_set_operation_splitter_ranks_detail;
// create the range [first1[partition_size], first1[2*partition_size], first1[3*partition_size], ...]
typedef typename splitter_iterator<RandomAccessIterator1>::type splitter_iterator1;
// we +1 to begin at first1[partition_size] instead of first1[0]
splitter_iterator1 splitters1_begin = make_splitter_iterator(first1, partition_size) + 1;
splitter_iterator1 splitters1_end = splitters1_begin + num_splitters_from_range1;
// create the range [first2[partition_size], first2[2*partition_size], first2[3*partition_size], ...]
typedef typename splitter_iterator<RandomAccessIterator2>::type splitter_iterator2;
// we +1 to begin at first2[partition_size] instead of first1[0]
splitter_iterator2 splitters2_begin = make_splitter_iterator(first2, partition_size) + 1;
splitter_iterator2 splitters2_end = splitters2_begin + num_splitters_from_range2;
typedef typename merge_iterator<splitter_iterator1,splitter_iterator2,Compare>::type merge_iterator;
// "merge" the splitters
merge_iterator splitters_begin = make_merge_iterator(splitters1_begin, splitters1_end,
splitters2_begin, splitters2_end,
comp);
merge_iterator splitters_end = splitters_begin + num_splitters_from_range1 + num_splitters_from_range2;
// find the rank of each splitter in the other range
thrust::lower_bound(first2, last2,
splitters_begin, splitters_end,
splitter_ranks2, comp);
thrust::lower_bound(first1, last1,
splitters_begin, splitters_end,
splitter_ranks1, comp);
} // end get_set_operation_splitter_ranks()
} // end detail
} // end cuda
} // end backend
} // end detail
} // end thrust
| [
"gregor@iut-monster.(none)"
] | gregor@iut-monster.(none) |
bf581359aed9534c5fcd2e529348ff2487c04cf5 | 2aa76fc5f5e9da740f83dedc002e7cecfad308e2 | /Objects/ChristmasTree.cpp | e4e6fe360bfc97543688291793fcf0f760ad261b | [] | no_license | AshleyIngram/3dGraphics | a8a2d43d848300875031684fbf16d170be9dae16 | 8cdd216e6c2484b16bb8d3114d4c2a6fcc14a126 | refs/heads/master | 2021-01-19T06:43:42.506549 | 2014-01-29T16:49:11 | 2014-01-29T16:49:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,691 | cpp | #include "ChristmasTree.h"
#include "Cylinder.h"
#include "ColouredSurface.h"
#include <iostream>
#include <sstream>
#include <string>
#include <stdlib.h>
#include "Sphere.h"
ChristmasTree::ChristmasTree(int seasons, Point origin) : Bone(getRoot())
{
this->seasons = seasons;
if (seasons == 0)
{
return;
}
ColouredSurface* brown = new ColouredSurface(0.33, 0.21, 0.04);
this->shape->setSurface(brown);
this->origin = origin;
this->seed = (rand() % 100) + 1;
this->initialRotation = 130;
}
ChristmasTree::ChristmasTree(int seasons, Point origin, int initialRotation) : Bone(getRoot())
{
this->seasons = seasons;
if (seasons == 0)
{
return;
}
ColouredSurface* brown = new ColouredSurface(0.33, 0.21, 0.04);
this->shape->setSurface(brown);
this->origin = origin;
this->seed = (rand() % 100) + 1;
this->initialRotation = initialRotation;
}
ChristmasTree::ChristmasTree(int seasons, Point origin, int initialRotation, uint seed) : Bone(getRoot())
{
this->seasons = seasons;
if (seasons == 0)
{
return;
}
ColouredSurface* brown = new ColouredSurface(0.33, 0.21, 0.04);
this->shape->setSurface(brown);
this->origin = origin;
this->seed = seed;
this->initialRotation = initialRotation;
}
Shape* ChristmasTree::getRoot()
{
return new Cylinder(0.05, 1.3, Point(0, 0, 0));
}
void ChristmasTree::render()
{
glEnable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
glPushMatrix();
glScalef(0.7, 0.7, 0.7);
glTranslatef(origin.x, origin.y, origin.z);
srand(seed);
// Render self
glPushMatrix();
glRotatef(90, 1, 0, 0);
this->shape->render();
glPopMatrix();
for (int i = 0; i < 360; i++)
{
if (i%90 == 0)
{
for (int j = 0; j < 3; j++)
{
glPushMatrix();
glTranslatef(0, 0.3 * j, 0);
glRotatef(i, 0, 1, 0);
// subtract j, giving the 'pyramid' style shape
growBranch(seasons-(1 + j/2), initialRotation, 0.2);
glPopMatrix();
}
}
}
// Grow a branch on top so the tree isn't balding.
glPushMatrix();
glTranslatef(0, 0.2, 0);
// glRotatef(0, 0, 1, 0);
growBranch(seasons-1, 270, 0.2);
glPopMatrix();
glPopMatrix();
glDisable(GL_LIGHTING);
}
void ChristmasTree::growBranch(int s, int rotation, int size)
{
if (s == 0)
{
return;
}
glPushMatrix();
// Rotate canvas around parent, to position correctly
glRotatef(rotation, 1, 0, 0);
drawCylinder(0.025, 0.2, rotation);
glTranslatef(0.0, 0, 0.05);
double r = r = ((double) rand() / (RAND_MAX));
// 30% chance of bauble
if (s == 1 && r < 0.4)
{
// Add a bauble on end branches
Shape bauble = Sphere(0.02, Point(0, 0, 0), 10);
ColouredSurface red = ColouredSurface(1, 0, 0);
ColouredSurface blue = ColouredSurface(0, 0, 1);
if (r < 0.2)
bauble.setSurface(&red);
else
bauble.setSurface(&blue);
glPushMatrix();
glTranslatef(0, 0.03, 0);
bauble.render();
glPopMatrix();
}
growBranch(s-1, -20, 0.4);
glTranslatef(0, 0, -(size/2));
growBranch(s-1, 20, 0.4);
glTranslatef(0, 0, -(size/2));
glPushMatrix();
glRotatef(90, 0, 1, 0);
growBranch(s-1, -20, 0.4);
glPopMatrix();
glPushMatrix();
glRotatef(-90, 0, 1, 0);
growBranch(s-1, -20, 0.4);
glPopMatrix();
// Pop the transforms applied in growBranch
glPopMatrix();
glPopMatrix();
}
void ChristmasTree::growTwig(int rotation)
{
drawCylinder(0.01, 0.2, rotation);
}
void ChristmasTree::drawCylinder(float r, float size, int rotation)
{
// Construct the actual shape
Shape shape = Cylinder(r, size, Point(0, 0, 0), 10);
ColouredSurface green = ColouredSurface(0.0, 0.392, 0.0);
shape.setSurface(&green);
// Translate to the end of the shape
glPushMatrix();
glTranslatef(0, 0, (size/2));
shape.render();
} | [
"ashley2504@hotmail.com"
] | ashley2504@hotmail.com |
bdbf5782f06b23ec1811e8b07272fe7a5dcfe057 | 6dfdf05f15f0fc10d3c4a37fae9cd2fd383d3d76 | /AA CODING/pattern_5.cpp | 2a4d1c5c23128b58870874b24c008ad30b6b0513 | [] | no_license | udghosh/Practice | 65e8418db1029e9500e601c078391d819ae1df8f | 67a51ff8d17a56e3536ce906e13160c13532cbc1 | refs/heads/main | 2023-06-03T22:45:27.466895 | 2021-06-16T07:46:25 | 2021-06-16T07:46:25 | 377,388,394 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 509 | cpp | #include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
int nstar = 1;
int nspace = n/2;
for(int i=1;i<=n;i++){
for(int j=1;j<=nspace;j++){
cout<<"\t";
}
for(int j=1;j<=nstar;j++){
cout<<"*\t";
}
if(i<=n/2){
nspace --;
nstar += 2;
}
else{
nspace ++;
nstar -= 2;
}
cout<<endl;
}
} | [
"noreply@github.com"
] | noreply@github.com |
d292ce70636a3707a6f347e75c52555529abe86c | 80f0c5422431e6c8df532c97716a0139dd61e93e | /tst/frame_tests/frame_tests.cpp | 8a01ce2c5436c317b3890be53ea39ae1aa0b73ce | [] | no_license | michalkielan/phone-controller | e614becacfacc5e2e83719ef65d1f001a02b02d9 | a39b8d30446698f4d410e3c101cb948e41e63281 | refs/heads/master | 2021-04-15T04:46:20.893970 | 2018-04-04T14:15:31 | 2018-04-04T14:15:31 | 126,894,064 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,281 | cpp | /*
* tests.cpp
*
* Created on: Mar 26, 2018
* Author: Michal Kielan
*/
#include "frame_tests.h"
#include "frame/frame_msg.h"
#include <string.h>
#include <stdio.h>
#include <random>
static const unsigned int iterations = 2000000;
TEST_F(FrameMessageTest, BufFrameConversion)
{
const int size = sizeof(FrameMessage);
char buf[size];
EXPECT_EQ(0, frame2buf(buf, &mMsg));
FrameMessage out;
EXPECT_EQ(0, buf2frame(&out, buf));
EXPECT_EQ(0, memcmp(&out, &mMsg, size));
}
TEST_F(FrameMessageTest, BufFrameConversionRandom)
{
const int size = sizeof(FrameMessage);
char buf[size];
unsigned int i=0;
while(++i < iterations)
{
for(int i=0; i<size; i++)
{
buf[i] = rand()%0xFF;
}
FrameMessage lhs, rhs;
ASSERT_EQ(0, frame2buf(buf, &lhs));
ASSERT_EQ(0, buf2frame(&rhs, buf));
ASSERT_EQ(0, memcmp(&lhs, &rhs, size));
}
}
TEST_F(FrameMessageTest, BufFrameNullCheck)
{
const int size = sizeof(FrameMessage);
char buf[size];
EXPECT_NE(0, frame2buf(NULL, &mMsg));
EXPECT_NE(0, frame2buf(buf, NULL));
EXPECT_NE(0, frame2buf(NULL, NULL));
EXPECT_NE(0, buf2frame(NULL, buf));
EXPECT_NE(0, buf2frame(&mMsg, NULL));
EXPECT_NE(0, buf2frame(NULL, NULL));
}
TEST_F(FrameMessageTest, ChecksumNullTest)
{
EXPECT_NE(0, set_crc(NULL));
EXPECT_NE(0, get_crc(NULL));
EXPECT_NE(0, check_crc(NULL));
EXPECT_EQ(0, set_crc(&mMsg));
EXPECT_EQ(0, check_crc(&mMsg));
EXPECT_GE(get_crc(&mMsg), 0);
EXPECT_EQ(get_crc(&mMsg), get_crc(&mMsg));
}
TEST_F(FrameMessageTest, ChecksumSameNumTest)
{
FrameMessage msg;
for(uint8_t i=0; i<0xFF; i++)
{
memset(&msg, i, sizeof(FrameMessage));
EXPECT_EQ(get_crc(&msg), 0);
}
}
TEST_F(FrameMessageTest, ChecksumRandom)
{
const int size = sizeof(FrameMessage);
char buf[size];
unsigned int i=0;
while(++i < iterations)
{
for(int i=0; i<size; i++)
{
buf[i] = rand()%0xFF;
}
FrameMessage msg;
ASSERT_EQ(0, buf2frame(&msg, buf));
ASSERT_EQ(0, set_crc(&msg));
ASSERT_EQ(0, set_crc(&msg));
ASSERT_EQ(0, set_crc(&msg));
ASSERT_EQ(0, set_crc(&msg));
ASSERT_EQ(0, set_crc(&msg));
ASSERT_EQ(0, check_crc(&msg));
ASSERT_GE(get_crc(&msg), 0);
ASSERT_EQ(get_crc(&msg), get_crc(&msg));
}
}
| [
"michalkielan@protonmail.com"
] | michalkielan@protonmail.com |
89006305d140338e4af568ade70d44005abf0b02 | 74f659d2e8b4b0681a10ff6e29228009cd89e58c | /game/card.hh | fa4d0a4a8298191a2f3bc3899870dca47dcac8d4 | [] | no_license | EliasOrma/CardGame | 6955e8208e35c8ef41cd94e6728171fd0478b008 | 5ad1d717ddbeba4479845ff22da755421bbb5363 | refs/heads/master | 2020-04-22T15:35:47.866708 | 2019-02-28T09:19:41 | 2019-02-28T09:19:41 | 170,482,209 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,833 | hh | #ifndef CARD_HH
#define CARD_HH
#include <QLabel>
#include <QFrame>
enum CardSuit {SPADE, CLUB, DIAMOND, HEART, SUIT_COUNT};
unsigned const DEFAULT_STACK_OFFSET = 30;
class Card : public QFrame
{
Q_OBJECT
public:
Card(CardSuit suit, unsigned value, QWidget *parent = 0);
// Kortin sisäisen tilan tarkastelemiseen ja muokkaamiseen.
bool isOpen();
void allowOpen();
// Kortin päällä olevien korttien käsittelemiseen.
void stackCard(Card* card, unsigned offset=DEFAULT_STACK_OFFSET);
void removeStackedCards();
// Palauttaa kortin tiedot (arvo, maa, onko auki) merkkijonona. Tarvitaan
// kortin raahaamisessa.
std::string getCardData();
// Kun korttia raahataan, raahaus-event tarvitsee kuvan, jota näytetään.
// Sen saa haettua tällä metodilla.
QLabel* getCurrentSideLabel();
signals:
// Kun kortin päälle (tai sen päällä olevien korttien päällä olevien korttien
// päälle) lisätään kortti, tarvii piirrettävän widgetin kokoa kasvattaa.
void resized();
public slots:
// Lisää toimenpiteitä, joita kortille voidaan suorittaa.
void turn();
void expand();
/*
protected:
// Itse toteutettu Qt:n widgetin klikkaamiseen liittyvä metodi.
//void mouseDoubleClickEvent(QMouseEvent* event);
*/
private:
// Apumetodeita muiden metodien käyttöön.
void setupLayout();
void setSuitPixmap();
void setupBack();
void setupFront();
// Korttiwidgetin sisäinen tila.
CardSuit suit_;
unsigned value_;
bool open_;
bool canOpen_;
// Kuvat joita tarvitaan, kun korttia piirretään setupBack- ja setupFront-metodeissa.
QPixmap suitPixmap_;
QPixmap backPixmap_;
// Osoitin kortin päällä mahdollisesti olevaan korttiin.
Card* stackedCard_;
};
#endif // CARD_HH
| [
"elias.orma@gmail.com"
] | elias.orma@gmail.com |
03c144befbea05b76967fe37a2aa57a274208e72 | e1a4acf1d41b152a0f811e82c27ad261315399cc | /include/data_management/data/numeric_table.h | 098504ef1f07bbd09a27aaf8042ed57d275374b0 | [
"Apache-2.0",
"Intel"
] | permissive | ValeryiE/daal | e7572f16e692785db1e17bed23b6ab709db4e705 | d326bdc5291612bc9e090d95da65aa579588b81e | refs/heads/master | 2020-08-29T11:37:16.157315 | 2019-10-25T13:11:01 | 2019-10-25T13:11:01 | 218,020,419 | 0 | 0 | Apache-2.0 | 2019-10-28T10:22:19 | 2019-10-28T10:22:19 | null | UTF-8 | C++ | false | false | 34,940 | h | /* file: numeric_table.h */
/*******************************************************************************
* Copyright 2014-2019 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
/*
//++
// Declaration and implementation of the base class for numeric tables.
//--
*/
#ifndef __NUMERIC_TABLE_H__
#define __NUMERIC_TABLE_H__
#include "services/base.h"
#include "services/daal_defines.h"
#include "services/daal_memory.h"
#include "services/error_handling.h"
#include "algorithms/algorithm_types.h"
#include "data_management/data/data_collection.h"
#include "data_management/data/data_dictionary.h"
#include "data_management/data/numeric_types.h"
namespace daal
{
/** \brief Contains classes that implement data management functionality, including NumericTables, DataSources, and Compression */
namespace data_management
{
namespace interface1
{
/**
* @ingroup numeric_tables
* @{
*/
class NumericTable;
/**
* <a name="DAAL-CLASS-DATA_MANAGEMENT__BLOCKDESCRIPTOR"></a>
* \brief %Base class that manages buffer memory for read/write operations required by numeric tables.
*/
template<typename DataType = DAAL_DATA_TYPE>
class DAAL_EXPORT BlockDescriptor
{
public:
/** \private */
BlockDescriptor() : _ptr(), _buffer(), _capacity(0), _ncols(0), _nrows(0), _colsOffset(0), _rowsOffset(0), _rwFlag(0), _pPtr(0), _rawPtr(0)
{}
/** \private */
~BlockDescriptor() { freeBuffer(); }
/**
* Gets a pointer to the buffer
* \return Pointer to the block
*/
inline DataType *getBlockPtr() const
{
if(_rawPtr)
{
return (DataType *)_rawPtr;
}
return _ptr.get();
}
/**
* Gets a pointer to the buffer
* \return Pointer to the block
*/
inline services::SharedPtr<DataType> getBlockSharedPtr() const
{
if(_rawPtr)
{
return services::SharedPtr<DataType>(services::reinterpretPointerCast<DataType, byte>(*_pPtr), (DataType *)_rawPtr);
}
return _ptr;
}
/**
* Returns the number of columns in the block
* \return Number of columns
*/
inline size_t getNumberOfColumns() const { return _ncols; }
/**
* Returns the number of rows in the block
* \return Number of rows
*/
inline size_t getNumberOfRows() const { return _nrows; }
/**
* Reset internal values and pointers to zero values
*/
inline void reset()
{
_colsOffset = 0;
_rowsOffset = 0;
_rwFlag = 0;
_pPtr = NULL;
_rawPtr = NULL;
}
public:
/**
* Sets data pointer to use for in-place calculation
* \param[in] ptr Pointer to the buffer
* \param[in] nColumns Number of columns
* \param[in] nRows Number of rows
*/
inline void setPtr( DataType *ptr, size_t nColumns, size_t nRows )
{
_ptr = services::SharedPtr<DataType>(ptr, services::EmptyDeleter());
_ncols = nColumns;
_nrows = nRows;
}
/**
* \param[in] pPtr Pointer to the shared pointer that handles the memory
* \param[in] rawPtr Pointer to she shifted memory
* \param[in] nColumns Number of columns
* \param[in] nRows Number of rows
*/
void setPtr(services::SharedPtr<byte> *pPtr, byte *rawPtr, size_t nColumns, size_t nRows )
{
_pPtr = pPtr;
_rawPtr = rawPtr;
_ncols = nColumns;
_nrows = nRows;
}
/**
* Allocates memory of (nColumns * nRows + auxMemorySize) size
* \param[in] nColumns Number of columns
* \param[in] nRows Number of rows
* \param[in] auxMemorySize Memory size
*
* \return true if memory of (nColumns * nRows + auxMemorySize) size is allocated successfully
*/
inline bool resizeBuffer( size_t nColumns, size_t nRows, size_t auxMemorySize = 0 )
{
_ncols = nColumns;
_nrows = nRows;
size_t newSize = nColumns * nRows * sizeof(DataType) + auxMemorySize;
if ( newSize > _capacity )
{
freeBuffer();
_buffer = services::SharedPtr<DataType>((DataType *)daal::services::daal_malloc(newSize), services::ServiceDeleter());
if ( _buffer != 0 )
{
_capacity = newSize;
}
else
{
return false;
}
}
_ptr = _buffer;
if(!auxMemorySize)
{
if(_aux_ptr)
{
_aux_ptr = services::SharedPtr<DataType>();
}
}
else
{
_aux_ptr = services::SharedPtr<DataType>(_buffer, _buffer.get() + nColumns * nRows);
}
return true;
}
/**
* Sets parameters of the block
* \param[in] columnIdx Index of the first column in the block
* \param[in] rowIdx Index of the first row in the block
* \param[in] rwFlag Flag specifying read/write access to the block
*/
inline void setDetails( size_t columnIdx, size_t rowIdx, int rwFlag )
{
_colsOffset = columnIdx;
_rowsOffset = rowIdx;
_rwFlag = rwFlag;
}
/**
* Gets the number of columns in the numeric table preceding the first element in the block
* \return columns offset
*/
inline size_t getColumnsOffset() const { return _colsOffset; }
/**
* Gets the number of rows in the numeric table preceding the first element in the block
* \return rows offset
*/
inline size_t getRowsOffset() const { return _rowsOffset; }
/**
* Gets the flag specifying read/write access to the block
* \return flag
*/
inline size_t getRWFlag() const { return _rwFlag; }
/**
* Gets a pointer o the additional memory buffer
* \return pointer
*/
inline void *getAdditionalBufferPtr() const { return _aux_ptr.get(); }
inline services::SharedPtr<DataType> getAdditionalBufferSharedPtr() const { return _aux_ptr; }
protected:
/**
* Frees the buffer
*/
void freeBuffer()
{
if(_buffer)
{
_buffer = services::SharedPtr<DataType>();
}
_capacity = 0;
}
private:
services::SharedPtr<DataType> _ptr;
size_t _nrows;
size_t _ncols;
size_t _colsOffset;
size_t _rowsOffset;
int _rwFlag;
services::SharedPtr<DataType> _aux_ptr;
services::SharedPtr<DataType> _buffer; /*<! Pointer to the buffer */
size_t _capacity; /*<! Buffer size in bytes */
services::SharedPtr<byte> *_pPtr;
byte *_rawPtr;
};
/**
* <a name="DAAL-CLASS-DATA_MANAGEMENT__NUMERICTABLEIFACE"></a>
* \brief Abstract interface class for a data management component responsible for representation of data in the numeric format.
* This class declares the most general methods for data access.
*/
class NumericTableIface
{
public:
virtual ~NumericTableIface()
{}
/**
* <a name="DAAL-ENUM-DATA_MANAGEMENT__MEMORYSTATUS"></a>
* \brief Enumeration to specify the status of memory related to the Numeric Table
*/
enum MemoryStatus
{
notAllocated, /*!< No memory allocated */
userAllocated, /*!< Memory allocated on user side */
internallyAllocated /*!< Memory allocated and managed by NumericTable */
};
/**
* <a name="DAAL-ENUM-DATA_MANAGEMENT__ALLOCATIONFLAG"></a>
* \brief Enumeration to specify whether the Numeric Table must allocate memory
*/
enum AllocationFlag
{
doNotAllocate = 0, /*!< Memory will not be allocated by NumericTable */
notAllocate = 0, /*!< Memory will not be allocated by NumericTable \DAAL_DEPRECATED_USE{ \ref daal::data_management::interface1::NumericTableIface::doNotAllocate "doNotAllocate" }*/
doAllocate = 1 /*!< Memory will be allocated by NumericTable when needed */
};
/**
* <a name="DAAL-ENUM-DATA_MANAGEMENT__BASICSTATISTICSID"></a>
* \brief Enumeration to specify estimates of basic statistics stored
*/
enum BasicStatisticsId
{
minimum = 0, /*!< Minimum estimate */
maximum = 1, /*!< Maximum estimate */
sum = 2, /*!< Sum estimate */
sumSquares = 3 /*!< Sum squares estimate */
};
/**
* <a name="DAAL-ENUM-DATA_MANAGEMENT__FEATUREBASICSTATISTICS"></a>
* \brief Enumeration to specify feature-specific estimates of basic statistics stored
*/
enum FeatureBasicStatistics
{
counters /*!< Counters estimate */
};
/**
* <a name="DAAL-ENUM-DATA_MANAGEMENT__NORMALIZATIONTYPE"></a>
* \brief Enumeration to specify types of normalization
*/
enum NormalizationType
{
nonNormalized = 0, /*!< Default: non-normalized */
standardScoreNormalized = 1, /*!< Standard score normalization (mean=0, variance=1) */
minMaxNormalized = 2 /*!< Min-max normalization */
};
/**
* <a name="DAAL-ENUM-DATA_MANAGEMENT__STORAGELAYOUT"></a>
* \brief Storage layouts that may need to be supported
*/
enum StorageLayout
{
soa = 1, // 1
aos = 2, // 2
csrArray = 1 << 4,
upperPackedSymmetricMatrix = 1 << 8,
lowerPackedSymmetricMatrix = 2 << 8,
upperPackedTriangularMatrix = 1 << 7,
lowerPackedTriangularMatrix = 4 << 8,
arrow = 8 << 8,
layout_unknown = 0x80000000 // the last bit set
};
/**
* Sets a data dictionary in the Numeric Table
* \param[in] ddict Pointer to the data dictionary
* \DAAL_DEPRECATED
*/
DAAL_DEPRECATED_VIRTUAL virtual services::Status setDictionary( NumericTableDictionary *ddict ) { return services::Status(); }
/**
* Returns a pointer to a data dictionary
* \return Pointer to the data dictionary
* \DAAL_DEPRECATED
*/
DAAL_DEPRECATED_VIRTUAL virtual NumericTableDictionary *getDictionary() const = 0;
/**
* Returns a shared pointer to a data dictionary
* \return Shared pointer to the data dictionary
*/
virtual NumericTableDictionaryPtr getDictionarySharedPtr() const = 0;
/**
* Resets a data dictionary for the Numeric Table
* \DAAL_DEPRECATED
*/
DAAL_DEPRECATED_VIRTUAL virtual services::Status resetDictionary() { return services::Status(); }
/**
* Returns the type of a given feature
* \param[in] feature_idx Feature index
* \return Feature type
*/
virtual features::FeatureType getFeatureType(size_t feature_idx) const = 0;
/**
* Returns the number of categories for a given feature
* \param[in] feature_idx Feature index
* \return Number of categories
*/
virtual size_t getNumberOfCategories(size_t feature_idx) const = 0;
/**
* Returns a data layout used in the Numeric Table
* \return Data layout
*/
virtual StorageLayout getDataLayout() const = 0;
/**
* Sets the number of rows in the Numeric Table and allocates memory for a data set
*/
virtual services::Status resize(size_t nrows) = 0;
/**
* Sets the number of columns in the Numeric Table
*
* \param[in] ncol Number of columns
* \DAAL_DEPRECATED
*/
DAAL_DEPRECATED_VIRTUAL virtual services::Status setNumberOfColumns(size_t ncol) = 0;
/**
* Sets the number of rows in the Numeric Table
*
* \param[in] nrow Number of rows
* \DAAL_DEPRECATED
*/
DAAL_DEPRECATED_VIRTUAL virtual services::Status setNumberOfRows(size_t nrow) = 0;
/**
* Allocates memory for a data set
* \DAAL_DEPRECATED
*/
DAAL_DEPRECATED_VIRTUAL virtual services::Status allocateDataMemory(daal::MemType type = daal::dram) = 0;
/**
* Deallocates the memory allocated for a data set
* \DAAL_DEPRECATED
*/
DAAL_DEPRECATED_VIRTUAL virtual void freeDataMemory() = 0;
/**
* Allocates Numeric Tables for basic statistics
*/
virtual services::Status allocateBasicStatistics() = 0;
/**
* Checks the correctness of this numeric table
* \param[in] description Additional information about error
* \param[in] checkDataAllocation Flag that specifies whether to check the data allocation status
* \return Check status: True if the table satisfies the requirements, false otherwise.
*/
virtual services::Status check(const char *description, bool checkDataAllocation = true) const = 0;
};
} // namespace interface1
using interface1::BlockDescriptor;
using interface1::NumericTableIface;
const int packed_mask = (int)NumericTableIface::csrArray |
(int)NumericTableIface::upperPackedSymmetricMatrix |
(int)NumericTableIface::lowerPackedSymmetricMatrix |
(int)NumericTableIface::upperPackedTriangularMatrix |
(int)NumericTableIface::lowerPackedTriangularMatrix;
namespace interface1
{
/**
* <a name="DAAL-CLASS-DATA_MANAGEMENT__DENSENUMERICTABLEIFACE"></a>
* \brief Abstract interface class for a data management component responsible for accessing data in the numeric format.
* This class declares specific methods to access data in a dense homogeneous form.
*/
class DenseNumericTableIface
{
public:
virtual ~DenseNumericTableIface()
{}
/**
* Gets a block of rows from a table.
*
* \param[in] vector_idx Index of the first row to include into the block.
* \param[in] vector_num Number of rows in the block.
* \param[in] rwflag Flag specifying read/write access to the block of feature vectors.
* \param[out] block The block of feature vectors.
*
* \return Actual number of feature vectors returned by the method.
*/
virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
/**
* Gets a block of rows from a table.
*
* \param[in] vector_idx Index of the first row to include into the block.
* \param[in] vector_num Number of rows in the block.
* \param[in] rwflag Flag specifying read/write access to the block of feature vectors.
* \param[out] block The block of feature vectors.
*
* \return Actual number of feature vectors returned by the method.
*/
virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
/**
* Gets a block of rows from a table.
*
* \param[in] vector_idx Index of the first row to include into the block.
* \param[in] vector_num Number of rows in the block.
* \param[in] rwflag Flag specifying read/write access to the block of feature vectors.
* \param[out] block The block of feature vectors.
*
* \return Actual number of feature vectors returned by the method.
*/
virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
/**
* Releases a block of rows.
* \param[in] block The block of rows.
*/
virtual services::Status releaseBlockOfRows(BlockDescriptor<double> &block) = 0;
/**
* Releases a block of rows.
* \param[in] block The block of rows.
*/
virtual services::Status releaseBlockOfRows(BlockDescriptor<float> &block) = 0;
/**
* Releases a block of rows.
* \param[in] block The block of rows.
*/
virtual services::Status releaseBlockOfRows(BlockDescriptor<int> &block) = 0;
/**
* Gets a block of values for a given feature.
*
* \param[in] feature_idx Feature index.
* \param[in] vector_idx Index of the first feature vector to include into the block.
* \param[in] value_num Number of feature values in the block.
* \param[in] rwflag Flag specifying read/write access to the block of feature values.
* \param[out] block The block of feature values.
*
* \return Actual number of feature values returned by the method.
*/
virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
/**
* Gets a block of values for a given feature.
*
* \param[in] feature_idx Feature index.
* \param[in] vector_idx Index of the first feature vector to include into the block.
* \param[in] value_num Number of feature values in the block.
* \param[in] rwflag Flag specifying read/write access to the block of feature values.
* \param[out] block The block of feature values.
*
* \return Actual number of feature values returned by the method.
*/
virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
/**
* Gets a block of values for a given feature.
*
* \param[in] feature_idx Feature index.
* \param[in] vector_idx Index of the first feature vector to include into the block.
* \param[in] value_num Number of feature values in the block.
* \param[in] rwflag Flag specifying read/write access to the block of feature values.
* \param[out] block The block of feature values.
*
* \return Actual number of feature values returned by the method.
*/
virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
/**
* Releases a block of values for a given feature.
* \param[in] block The block of feature values.
*/
virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) = 0;
/**
* Releases a block of values for a given feature.
* \param[in] block The block of feature values.
*/
virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) = 0;
/**
* Releases a block of values for a given feature.
* \param[in] block The block of feature values.
*/
virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) = 0;
};
/**
* <a name="DAAL-CLASS-DATA_MANAGEMENT__NUMERICTABLE"></a>
* \brief Class for a data management component responsible for representation of data in the numeric format.
* This class implements the most general methods for data access.
*/
class DAAL_EXPORT NumericTable : public SerializationIface, public NumericTableIface, public DenseNumericTableIface
{
public:
DAAL_CAST_OPERATOR(NumericTable);
/**
* Constructor for a Numeric Table with predefined dictionary
* \param[in] ddict Pointer to the data dictionary
* \DAAL_DEPRECATED
*/
DAAL_DEPRECATED NumericTable( NumericTableDictionary *ddict )
{
_obsnum = 0;
_ddict = NumericTableDictionaryPtr(ddict, services::EmptyDeleter());
_layout = layout_unknown;
_memStatus = notAllocated;
_normalizationFlag = NumericTable::nonNormalized;
}
/**
* Constructor for a Numeric Table with predefined dictionary
* \param[in] ddict Pointer to the data dictionary
*/
NumericTable( NumericTableDictionaryPtr ddict )
{
_obsnum = 0;
_ddict = ddict;
_layout = layout_unknown;
_memStatus = notAllocated;
_normalizationFlag = NumericTable::nonNormalized;
}
/**
* Constructor for a Numeric Table
* \param[in] featnum Number of columns in the table
* \param[in] obsnum Number of rows in the table
* \param[in] featuresEqual Flag that makes all features in the Numeric Table Data Dictionary equal
*/
NumericTable( size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual = DictionaryIface::notEqual )
{
_obsnum = obsnum;
_ddict = NumericTableDictionaryPtr(new NumericTableDictionary(featnum, featuresEqual));
_layout = layout_unknown;
_memStatus = notAllocated;
_normalizationFlag = NumericTable::nonNormalized;
}
/** \private */
virtual ~NumericTable() {}
DAAL_DEPRECATED_VIRTUAL virtual services::Status setDictionary( NumericTableDictionary *ddict ) DAAL_C11_OVERRIDE
{
_ddict = NumericTableDictionaryPtr(ddict, services::EmptyDeleter());
return services::Status();
}
DAAL_DEPRECATED_VIRTUAL virtual NumericTableDictionary *getDictionary() const DAAL_C11_OVERRIDE { return _ddict.get(); }
virtual NumericTableDictionaryPtr getDictionarySharedPtr() const DAAL_C11_OVERRIDE { return _ddict; }
DAAL_DEPRECATED_VIRTUAL virtual services::Status resetDictionary() DAAL_C11_OVERRIDE { return services::Status(); }
virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
{
size_t obsnum = _obsnum;
services::Status s = setNumberOfRowsImpl(nrows);
if((_memStatus != userAllocated && obsnum < nrows) || _memStatus == notAllocated)
{
s |= allocateDataMemoryImpl();
}
return s;
}
/**
* Returns the number of columns in the Numeric Table
* \return Number of columns
*/
size_t getNumberOfColumns() const
{
return _ddict->getNumberOfFeatures();
}
/**
* Returns the number of rows in the Numeric Table
* \return Number of rows
*/
size_t getNumberOfRows() const { return _obsnum; }
DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfColumns(size_t ncol) DAAL_C11_OVERRIDE
{
return setNumberOfColumnsImpl(ncol);
}
DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfRows(size_t nrow) DAAL_C11_OVERRIDE
{
return setNumberOfRowsImpl(nrow);
}
DAAL_DEPRECATED_VIRTUAL services::Status allocateDataMemory(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
{
return allocateDataMemoryImpl(type);
}
DAAL_DEPRECATED_VIRTUAL void freeDataMemory() DAAL_C11_OVERRIDE
{
freeDataMemoryImpl();
}
StorageLayout getDataLayout() const DAAL_C11_OVERRIDE
{
return _layout;
}
features::FeatureType getFeatureType(size_t feature_idx) const DAAL_C11_OVERRIDE
{
if ( _ddict.get() != NULL && _ddict->getNumberOfFeatures() > feature_idx )
{
const NumericTableFeature &f = (*_ddict)[feature_idx];
return f.featureType;
}
else
{
/* If no dictionary was set, all features are considered numeric */
return features::DAAL_CONTINUOUS;
}
}
size_t getNumberOfCategories(size_t feature_idx) const DAAL_C11_OVERRIDE
{
if ( _ddict.get() != NULL && _ddict->getNumberOfFeatures() > feature_idx &&
getFeatureType(feature_idx) != features::DAAL_CONTINUOUS )
{
const NumericTableFeature &f = (*_ddict)[feature_idx];
return f.categoryNumber;
}
else
{
/* If no dictionary was set, all features are considered numeric */
return -1;
}
}
/**
* Gets the status of the memory used by a data set connected with a Numeric Table
*/
virtual MemoryStatus getDataMemoryStatus() const { return _memStatus; }
/**
* Checks if dataset stored in the numeric table is normalized, according to the given normalization flag
* \param[in] flag Normalization flag to check
* \return Check result
*/
bool isNormalized(NormalizationType flag) const
{
return (_normalizationFlag == flag);
}
/**
* Sets the normalization flag for dataset stored in the numeric table
* \param[in] flag Normalization flag
* \return Previous value of the normalization flag
*/
NormalizationType setNormalizationFlag(NormalizationType flag)
{
NormalizationType oldValue = _normalizationFlag;
_normalizationFlag = flag;
return oldValue;
}
/**
* Returns errors during the computation
* \return Errors during the computation
* \DAAL_DEPRECATED
*/
DAAL_DEPRECATED services::SharedPtr<services::KernelErrorCollection> getErrors()
{
return _status.getCollection()->getErrors();
}
/**
* Allocates Numeric Tables for basic statistics
*/
virtual services::Status allocateBasicStatistics() DAAL_C11_OVERRIDE;
/**
* \copydoc NumericTableIface::check
*/
virtual services::Status check(const char *description, bool checkDataAllocation = true) const DAAL_C11_OVERRIDE
{
if (getDataMemoryStatus() == notAllocated && checkDataAllocation)
{
return services::Status(services::Error::create(services::ErrorNullNumericTable, services::ArgumentName, description));
}
if (getNumberOfColumns() == 0)
{
return services::Status(services::Error::create(services::ErrorIncorrectNumberOfColumns, services::ArgumentName, description));
}
if (getNumberOfRows() == 0 && getDataMemoryStatus() != notAllocated)
{
return services::Status(services::Error::create(services::ErrorIncorrectNumberOfRows, services::ArgumentName, description));
}
return services::Status();
}
/**
* Fills a numeric table with a constant
* \param[in] value Constant to initialize entries of the numeric table
*/
virtual services::Status assign(float value) {return assignImpl<float>(value);}
/**
* Fills a numeric table with a constant
* \param[in] value Constant to initialize entries of the numeric table
*/
virtual services::Status assign(double value) {return assignImpl<double>(value);}
/**
* Fills a numeric table with a constant
* \param[in] value Constant to initialize entries of the numeric table
*/
virtual services::Status assign(int value) {return assignImpl<int>(value);}
/**
* Returns value by given column and row from the numeric table
* \param[in] column Column
* \param[in] row Row
* \return Value from numeric table
*/
template <typename DataType>
DataType getValue(size_t column, size_t row) const
{
services::Status status;
return getValueImpl<DataType>(column, row, status);
}
/**
* Returns value by given column and row from the numeric table
* \param[in] column Column
* \param[in] row Row
* \param[in,out] status Status of the operation
* \return Value from numeric table
*/
template <typename DataType>
DataType getValue(size_t column, size_t row, services::Status & status) const
{
return getValueImpl<DataType>(column, row, status);
}
public:
/**
* <a name="DAAL-CLASS-DATA_MANAGEMENT__BASICSTATISTICSDATACOLLECTION"></a>
* \brief Basic statistics for each column of original Numeric Table
*/
class BasicStatisticsDataCollection : public algorithms::Argument
{
public:
BasicStatisticsDataCollection() : algorithms::Argument(4) {}
services::SharedPtr<NumericTable> get(BasicStatisticsId id)
{
return services::staticPointerCast<NumericTable, SerializationIface>(Argument::get(id));
}
void set(BasicStatisticsId id, const services::SharedPtr<NumericTable> &value)
{
Argument::set(id, value);
}
};
BasicStatisticsDataCollection basicStatistics; /** Basic statistics container */
protected:
NumericTableDictionaryPtr _ddict;
size_t _obsnum;
MemoryStatus _memStatus;
StorageLayout _layout;
NormalizationType _normalizationFlag;
services::Status _status;
protected:
NumericTable(NumericTableDictionaryPtr ddict, services::Status &st) :
_obsnum(0), _ddict(ddict), _layout(layout_unknown), _memStatus(notAllocated), _normalizationFlag(NumericTable::nonNormalized)
{
}
NumericTable(size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual, services::Status &st):
_obsnum(obsnum), _layout(layout_unknown), _memStatus(notAllocated), _normalizationFlag(NumericTable::nonNormalized)
{
_ddict = NumericTableDictionary::create(featnum, featuresEqual, &st);
if (!st) return;
}
virtual services::Status setNumberOfColumnsImpl(size_t ncol)
{
return _ddict->setNumberOfFeatures(ncol);
}
virtual services::Status setNumberOfRowsImpl(size_t nrow)
{
_obsnum = nrow;
return services::Status();
}
virtual services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) { return services::Status(); }
virtual void freeDataMemoryImpl() {}
template <typename DataType>
DataType getValueImpl(size_t column, size_t row, services::Status & status) const
{
const DataType defaultValue = 0;
if (!status)
return defaultValue;
BlockDescriptor<DataType> bd;
status |= const_cast<NumericTable *>(this)->getBlockOfColumnValues(column, row, 1, readOnly, bd);
if (!status)
return defaultValue;
const DataType v = *(bd.getBlockPtr());
status |= const_cast<NumericTable *>(this)->releaseBlockOfColumnValues(bd);
return v;
}
virtual float getFloatValueImpl(size_t column, size_t row, services::Status & status) const
{
return getValueImpl<float>(column, row, status);
}
virtual double getDoubleValueImpl(size_t column, size_t row, services::Status & status) const
{
return getValueImpl<double>(column, row, status);
}
virtual int getIntValueImpl(size_t column, size_t row, services::Status & status) const
{
return getValueImpl<int>(column, row, status);
}
/** \private */
template<typename Archive, bool onDeserialize>
services::Status serialImpl( Archive *arch )
{
arch->setSharedPtrObj( _ddict );
arch->set( _obsnum );
if( onDeserialize )
{
_memStatus = notAllocated;
}
arch->set( _layout );
return services::Status();
}
private:
template <typename T>
services::Status assignImpl(T value)
{
size_t nRows = getNumberOfRows();
size_t nCols = getNumberOfColumns();
BlockDescriptor<T> block;
DAAL_CHECK(getBlockOfRows(0, nRows, writeOnly, block), services::ErrorMemoryAllocationFailed)
T* array = block.getBlockSharedPtr().get();
for(size_t i = 0; i < nCols * nRows; i++) {array[i] = value;}
releaseBlockOfRows(block);
return services::Status();
}
};
typedef services::SharedPtr<NumericTable> NumericTablePtr;
typedef services::SharedPtr<const NumericTable> NumericTableConstPtr;
template <>
inline float NumericTable::getValue<float>(size_t column, size_t row) const
{
services::Status status;
return getFloatValueImpl(column, row, status);
}
template <>
inline double NumericTable::getValue<double>(size_t column, size_t row) const
{
services::Status status;
return getDoubleValueImpl(column, row, status);
}
template <>
inline int NumericTable::getValue<int>(size_t column, size_t row) const
{
services::Status status;
return getIntValueImpl(column, row, status);
}
template <>
inline float NumericTable::getValue<float>(size_t column, size_t row, services::Status & status) const
{
return getFloatValueImpl(column, row, status);
}
template <>
inline double NumericTable::getValue<double>(size_t column, size_t row, services::Status & status) const
{
return getDoubleValueImpl(column, row, status);
}
template <>
inline int NumericTable::getValue<int>(size_t column, size_t row, services::Status & status) const
{
return getIntValueImpl(column, row, status);
}
/** @} */
} // namespace interface1
using interface1::DenseNumericTableIface;
using interface1::NumericTable;
using interface1::NumericTablePtr;
using interface1::NumericTableConstPtr;
/**
* Checks the correctness of this numeric table
* \param[in] nt The numeric table to check
* \param[in] description Additional information about error
* \param[in] unexpectedLayouts The bit mask of invalid layouts for this numeric table.
* \param[in] expectedLayouts The bit mask of valid layouts for this numeric table.
* \param[in] nColumns Required number of columns.
* nColumns = 0 means that required number of columns is not specified.
* \param[in] nRows Required number of rows.
* nRows = 0 means that required number of rows is not specified.
* \param[in] checkDataAllocation Flag that specifies whether to check the data allocation status
* \return Check status: True if the table satisfies the requirements, false otherwise.
*/
DAAL_EXPORT services::Status checkNumericTable(const NumericTable *nt, const char *description,
const int unexpectedLayouts = 0, const int expectedLayouts = 0, size_t nColumns = 0, size_t nRows = 0,
bool checkDataAllocation = true);
/**
* Converts numeric table with arbitrary storage layout to homogen numeric table of the given type
* \param[in] src Pointer to numeric table
* \param[in] type Type of result numeric table memory
* \return Pointer to homogen numeric table
*/
template<typename DataType>
DAAL_EXPORT daal::data_management::NumericTablePtr convertToHomogen(NumericTable &src, daal::MemType type = daal::dram);
}
} // namespace daal
#endif
| [
"nikolay.a.petrov@intel.com"
] | nikolay.a.petrov@intel.com |
152b0d7c4d96c1708545811478eee888cfd16a17 | a536e277c34053f1ebc67fec3305d4687b3d0e0d | /detect_aruco_video.cpp | 1dc5d21613bf4eb3a12f762d77ce8e59ba26c3d3 | [] | no_license | NotArtyom/OpenCV_CPP | f06d3885d143714ef2ca187a03fae738e2dc2f0f | af9d30ca9296b2e85a34d1362f706df7a61feec9 | refs/heads/master | 2022-08-27T15:53:25.082756 | 2020-05-19T20:34:36 | 2020-05-19T20:34:36 | 265,359,301 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,354 | cpp | #include <opencv2/aruco.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/imgcodecs.hpp>
void detect() {
cv::VideoCapture inputVideo;
inputVideo.open(0);
cv::Mat cameraMatrix, distCoeffs;
// camera parameters are read from somewhere
readCameraParameters(cameraMatrix, distCoeffs);
cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
while (inputVideo.grab()) {
cv::Mat image, imageCopy;
inputVideo.retrieve(image);
image.copyTo(imageCopy);
std::vector<int> ids;
std::vector<std::vector<cv::Point2f>> corners;
cv::aruco::detectMarkers(image, dictionary, corners, ids);
// if at least one marker detected
if (ids.size() > 0) {
cv::aruco::drawDetectedMarkers(imageCopy, corners, ids);
std::vector<cv::Vec3d> rvecs, tvecs;
cv::aruco::estimatePoseSingleMarkers(corners, 0.05, cameraMatrix, distCoeffs, rvecs, tvecs);
// draw axis for each marker
for(int i=0; i<ids.size(); i++)
cv::aruco::drawAxis(imageCopy, cameraMatrix, distCoeffs, rvecs[i], tvecs[i], 0.1);
}
cv::imshow("out", imageCopy);
char key = (char) cv::waitKey(waitTime);
if (key == 27)
break;
}
}
int main() {
detect();
} | [
"smart.artyom@gmail.com"
] | smart.artyom@gmail.com |
36677ac853fba91204bbc7e7b1aaac6b8e805119 | 97168ebc9dc4f9e2dd6c07f20ff6001904dc1157 | /bl4ckJack/boost_1_45_0/libs/functional/hash/test/hash_number_test.cpp | 91b9b92d1466f9eb6f7841e7570aa36aac330201 | [
"BSL-1.0"
] | permissive | redsand/bl4ckJack | 587f60f0eaa9a8710e07c591e602b8af5bed6ba9 | e0f913dc4b015ea8b0c437ade5c42aad33b63bde | refs/heads/master | 2021-01-10T18:07:04.446579 | 2011-02-15T03:32:54 | 2011-02-15T03:32:54 | 1,218,155 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,915 | cpp |
// Copyright 2005-2009 Daniel James.
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include "./config.hpp"
#ifdef TEST_STD_INCLUDES
# include <functional>
#else
# include <boost/functional/hash.hpp>
#endif
#include <iostream>
#include <boost/detail/lightweight_test.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/functional/hash/detail/limits.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include "./compile_time.hpp"
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable:4127) // conditional expression is constant
#pragma warning(disable:4309) // truncation of constant value
#pragma warning(disable:4310) // cast truncates constant value
#endif
template <class T>
void numeric_test(T*)
{
typedef boost::hash_detail::limits<T> limits;
compile_time_tests((T*) 0);
HASH_NAMESPACE::hash<T> x1;
HASH_NAMESPACE::hash<T> x2;
T v1 = (T) -5;
BOOST_TEST(x1(v1) == x2(v1));
BOOST_TEST(x1(T(-5)) == x2(T(-5)));
BOOST_TEST(x1(T(0)) == x2(T(0)));
BOOST_TEST(x1(T(10)) == x2(T(10)));
BOOST_TEST(x1(T(25)) == x2(T(25)));
BOOST_TEST(x1(T(5) - T(5)) == x2(T(0)));
BOOST_TEST(x1(T(6) + T(4)) == x2(T(10)));
#if defined(TEST_EXTENSIONS)
BOOST_TEST(x1(T(-5)) == HASH_NAMESPACE::hash_value(T(-5)));
BOOST_TEST(x1(T(0)) == HASH_NAMESPACE::hash_value(T(0)));
BOOST_TEST(x1(T(10)) == HASH_NAMESPACE::hash_value(T(10)));
BOOST_TEST(x1(T(25)) == HASH_NAMESPACE::hash_value(T(25)));
if (limits::is_integer)
{
if(limits::is_signed ||
limits::digits <= boost::hash_detail::limits<std::size_t>::digits)
{
BOOST_TEST(HASH_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5));
}
BOOST_TEST(HASH_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u));
BOOST_TEST(HASH_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u));
BOOST_TEST(HASH_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u));
}
#endif
}
template <class T>
void limits_test(T*)
{
typedef boost::hash_detail::limits<T> limits;
if(limits::is_specialized)
{
HASH_NAMESPACE::hash<T> x1;
HASH_NAMESPACE::hash<T> x2;
T min_value = (limits::min)();
T max_value = (limits::max)();
BOOST_TEST(x1(min_value) == x2((limits::min)()));
BOOST_TEST(x1(max_value) == x2((limits::max)()));
#if defined(TEST_EXTENSIONS)
BOOST_TEST(x1(min_value) == HASH_NAMESPACE::hash_value(min_value));
BOOST_TEST(x1(max_value) == HASH_NAMESPACE::hash_value(max_value));
if (limits::is_integer)
{
BOOST_TEST(HASH_NAMESPACE::hash_value(min_value)
== std::size_t(min_value));
BOOST_TEST(HASH_NAMESPACE::hash_value(max_value)
== std::size_t(max_value));
}
#endif
}
}
template <class T>
void poor_quality_tests(T*)
{
typedef boost::hash_detail::limits<T> limits;
HASH_NAMESPACE::hash<T> x1;
HASH_NAMESPACE::hash<T> x2;
// A hash function can legally fail these tests, but it'll not be a good
// sign.
if(T(1) != T(-1))
BOOST_TEST(x1(T(1)) != x2(T(-1)));
if(T(1) != T(2))
BOOST_TEST(x1(T(1)) != x2(T(2)));
if((limits::max)() != (limits::max)() - 1)
BOOST_TEST(x1((limits::max)()) != x2((limits::max)() - 1));
}
void bool_test()
{
HASH_NAMESPACE::hash<bool> x1;
HASH_NAMESPACE::hash<bool> x2;
BOOST_TEST(x1(true) == x2(true));
BOOST_TEST(x1(false) == x2(false));
BOOST_TEST(x1(true) != x2(false));
BOOST_TEST(x1(false) != x2(true));
}
#define NUMERIC_TEST(type, name) \
std::cerr<<"Testing: " BOOST_STRINGIZE(name) "\n"; \
numeric_test((type*) 0); \
limits_test((type*) 0); \
poor_quality_tests((type*) 0);
#define NUMERIC_TEST_NO_LIMITS(type, name) \
std::cerr<<"Testing: " BOOST_STRINGIZE(name) "\n"; \
numeric_test((type*) 0); \
poor_quality_tests((type*) 0);
int main()
{
NUMERIC_TEST(char, char)
NUMERIC_TEST(signed char, schar)
NUMERIC_TEST(unsigned char, uchar)
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
NUMERIC_TEST(wchar_t, wchar)
#endif
NUMERIC_TEST(short, short)
NUMERIC_TEST(unsigned short, ushort)
NUMERIC_TEST(int, int)
NUMERIC_TEST(unsigned int, uint)
NUMERIC_TEST(long, hash_long)
NUMERIC_TEST(unsigned long, ulong)
#if !defined(BOOST_NO_LONG_LONG)
NUMERIC_TEST_NO_LIMITS(boost::long_long_type, long_long)
NUMERIC_TEST_NO_LIMITS(boost::ulong_long_type, ulong_long)
#endif
NUMERIC_TEST(float, float)
NUMERIC_TEST(double, double)
NUMERIC_TEST(std::size_t, size_t)
NUMERIC_TEST(std::ptrdiff_t, ptrdiff_t)
bool_test();
return boost::report_errors();
}
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif
| [
"redsand@redsand.net"
] | redsand@redsand.net |
ef69c34829cd5133d754d28588cc5f1e78169af2 | 9ada6ca9bd5e669eb3e903f900bae306bf7fd75e | /case3/ddtFoam_Tutorial/0.006400000/tau | 900814a0d000d4fec4c417a26c3155fb33a0c29f | [] | no_license | ptroyen/DDT | a6c8747f3a924a7039b71c96ee7d4a1618ad4197 | 6e6ddc7937324b04b22fbfcf974f9c9ea24e48bf | refs/heads/master | 2020-05-24T15:04:39.786689 | 2018-01-28T21:36:40 | 2018-01-28T21:36:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,063 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.1.1 |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0.006400000";
object tau;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 1;
boundaryField
{
wand
{
type zeroGradient;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //
| [
"ubuntu@ip-172-31-45-175.eu-west-1.compute.internal"
] | ubuntu@ip-172-31-45-175.eu-west-1.compute.internal | |
873c13e3ebfea7e47b1b20257c9c0952a89d1c2e | d053e0e8687f122d120bcd0fa1f9076deb35afa5 | /Olymp/CF/263/D.cpp | d889c3a72db15679c86efdc069105e33a8a867ec | [] | no_license | shaihitdin/CP | e8911bc543932866d6fc83eb1d48d9cf79918c61 | dc90082f3ebedaccbfb0818cc68539c887f86553 | refs/heads/master | 2021-01-11T17:10:20.356635 | 2017-10-05T08:53:56 | 2017-10-05T08:53:56 | 79,729,913 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 667 | cpp | #include<iostream>
#include<stdio.h>
#include<vector>
using namespace std;
vector<long long> g[100001];
long long n,i,j,root,col[100001],ans,sz[100001];
void dfs(long long v){
u[v]=1;
for(int i=0;i<g[v].size();++i){
if(!u[g[v][i]]){
dfs(g[v][i]);
ans*=sz[g[v][i]];
}
}
if(col[v]){
sz[v]=1;
}
else{
sz[v]
}
}
int main(){
#ifndef ONLINE_JUDGE
freopen("in","r",stdin);
freopen("out","w",stdout);
#endif
scanf("%I64d",&n);
for(i=1;i<n;++i){
scanf("%I64d",&x);
++x;
g[x].push_back(i+1);
g[i+1].push_back(x);
}
for(i=1;i<=n;++i){
scanf("%I64d",&col[i]);
if(col[i]) root=i;
}
ans=1;
dfs(root);
printf("%I64d",ans);
return 0;
} | [
"shaihitdin@gmail.com"
] | shaihitdin@gmail.com |
4f5c51d02dfd697dba6c781b5df1ce7eeb558f5a | e81aa78090243682e8fe0dd391397b963e3bf1e3 | /src/party.hpp | 71d81e93a4e08bdfa473a3e9cb82cd0f8ee111b8 | [
"Zlib"
] | permissive | eoserv/eoserv | 2fee2964c42d98d63ba0a3d3ea90f3ec17d78ab3 | 7025373affd41edeeee141fc83a1d453767c3688 | refs/heads/master | 2022-12-26T10:13:20.396094 | 2022-12-24T07:37:45 | 2022-12-24T08:09:19 | 235,367,374 | 27 | 18 | null | null | null | null | UTF-8 | C++ | false | false | 821 | hpp | /* party.hpp
* EOSERV is released under the zlib license.
* See LICENSE.txt for more info.
*/
#ifndef PARTY_HPP_INCLUDED
#define PARTY_HPP_INCLUDED
#include "fwd/party.hpp"
#include "fwd/character.hpp"
#include "fwd/map.hpp"
#include "fwd/world.hpp"
#include <string>
#include <vector>
/**
* A temporary group of Characters
*/
class Party
{
public:
World *world;
Character *leader;
std::vector<Character *> members;
int temp_expsum;
Party(World *world, Character *leader, Character *other);
void Msg(Character *from, std::string message, bool echo = true);
void Join(Character *);
void Leave(Character *);
void RefreshMembers(Character *, bool create = false);
void UpdateHP(Character *);
void ShareEXP(int exp, int sharemode, Map *map);
~Party();
};
#endif // PARTY_HPP_INCLUDED
| [
"sausage@tehsausage.com"
] | sausage@tehsausage.com |
b86c9586b25033899135866cdc536bc225ae2a28 | 1eede6e4f928219f0984e6ae4d9192389c34ef60 | /AteOscHardwareTester/AteOscHardwareTester.cpp | e18969ecd58c3b0822b0053a861f75015186a662 | [] | no_license | rio-rattenrudel/libraries | 574ac687f12bcec7340efd1614aec48523872922 | 664afa7a2430bd0ec24646f26deec4005dd9a5b3 | refs/heads/master | 2023-07-17T09:02:21.426680 | 2021-09-01T11:36:22 | 2021-09-01T11:36:22 | 400,464,218 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,473 | cpp | //AteOscHardwareTester.cpp Atmegatron Hardware Tester. Used by assembly factory.
//Copyright (C) 2015 Paul Soulsby info@soulsbysynths.com
//
//This program is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "AteOscHardwareTester.h"
extern void writeFram(const void* data, unsigned int startAddr, size_t size);
extern void readFram(void* data, unsigned int startAddr, size_t size);
extern void writeMemory(const void* data, void* startAddr, size_t size);
extern void readMemory(void* data, const void* startAddr, size_t size);
// default constructor
AteOscHardwareTester::AteOscHardwareTester() : hardware_(AteOscHardware::getInstance())
{
hardware_.construct(this);
audio_ = new AtmAudio(WAVE_LEN);
} //AteOscHardwareTester
// default destructor
AteOscHardwareTester::~AteOscHardwareTester()
{
} //~AteOscHardwareTester
#ifdef _DEBUG==1
void AteOscHardwareTester::init()
{
audio_->initialize();
audio_->setSampleFreq((unsigned long)WAVE_LEN * 440);
refreshSineWave();
//Serial.begin(9600);
}
void AteOscHardwareTester::initMemory()
{
unsigned int addr = 0;
unsigned char framBuffer[OSC_WAVELEN] = {0};
unsigned char eepromBuffer[PATCH_SIZE] = {0};
unsigned char i,j,k;
clearLeds();
//init fram
hardware_.refreshLeds();
for(i=0;i<OSC_BANKS;++i)
{
hardware_.getLedCircular(AteOscHardware::FUNCTION).select(i);
for (j=0;j<OSC_TABLES;++j)
{
hardware_.getLedCircular(AteOscHardware::VALUE).select(j);
hardware_.refreshLeds();
for(k=0;k<OSC_WAVELEN;++k)
{
framBuffer[k] = pgm_read_byte(&(OSC_WAVETABLE[i][j][k]));
}
writeFram((const void*)framBuffer, addr, sizeof(framBuffer));
readFram((void*)framBuffer, addr, sizeof(framBuffer));
for(k=0;k<OSC_WAVELEN;++k)
{
if(framBuffer[k]!=pgm_read_byte(&(OSC_WAVETABLE[i][j][k])))
{
hardware_.refreshLeds();
for(;;){} //STOP
}
}
addr += OSC_WAVELEN;
}
}
//init eeprom
hardware_.refreshLeds();
addr = 0;
hardware_.getLedCircular(AteOscHardware::FUNCTION).select(0);
for(i=0;i<PATCHES;++i)
{
hardware_.getLedCircular(AteOscHardware::VALUE).select(i);
hardware_.refreshLeds();
for(j=0;j<PATCH_SIZE;++j)
{
eepromBuffer[j] = pgm_read_byte(&(PATCH_DATA[i][j]));
}
writeMemory((const void*)eepromBuffer, (void*)addr, sizeof(eepromBuffer));
readMemory((void*)eepromBuffer,(const void*)addr, sizeof(eepromBuffer));
for(j=0;j<PATCH_SIZE;++j)
{
if(eepromBuffer[j]!=pgm_read_byte(&(PATCH_DATA[i][j])))
{
hardware_.refreshLeds();
for(;;){} //STOP
}
}
addr += PATCH_SIZE;
}
hardware_.getLedCircular(AteOscHardware::FUNCTION).select(1);
hardware_.refreshLeds();
//global settings
hardware_.writeEepromByte(AteOscHardware::EEPROM_CURRENT_PATCH, 0);
hardware_.writeEepromByte(AteOscHardware::EEPROM_CTRL_MODE, 0);
hardware_.writeEepromByte(AteOscHardware::EEPROM_CLOCK_MODE, 0);
hardware_.writeEepromByte(AteOscHardware::EEPROM_QUANT_KEY, 0);
hardware_.writeEepromByte(AteOscHardware::EEPROM_PITCH_LOW, 0x04); //1024 1.25V 77.8Hz msb
hardware_.writeEepromByte(AteOscHardware::EEPROM_PITCH_LOW+1, 0x00); //1024 1.25V 77.8Hz lsb
hardware_.writeEepromByte(AteOscHardware::EEPROM_PITCH_HIGH, 0x0C); //3072 3.75V 440Hz msb
hardware_.writeEepromByte(AteOscHardware::EEPROM_PITCH_HIGH+1, 0x00); //3072 3.75V 440Hz lsb
hardware_.writeEepromByte(AteOscHardware::EEPROM_FILT_LOW, 0x04); //1024 1.25V 77.8Hz msb
hardware_.writeEepromByte(AteOscHardware::EEPROM_FILT_LOW+1, 0x00); //1024 1.25V 77.8Hz lsb
hardware_.writeEepromByte(AteOscHardware::EEPROM_FILT_HIGH, 0x0C); //3072 3.75V 440Hz msb
hardware_.writeEepromByte(AteOscHardware::EEPROM_FILT_HIGH+1, 0x00); //3072 3.75V 440Hz lsb
hardware_.readCvCalib(AteOscHardware::EEPROM_PITCH_LOW);
hardware_.readCvCalib(AteOscHardware::EEPROM_PITCH_HIGH);
hardware_.readCvCalib(AteOscHardware::EEPROM_FILT_LOW);
hardware_.readCvCalib(AteOscHardware::EEPROM_FILT_HIGH);
clearLeds();
}
void AteOscHardwareTester::clearLeds()
{
for(unsigned char i=0;i<2;++i)
{
hardware_.getLedCircular(i).setState(0);
}
hardware_.refreshLeds();
}
void AteOscHardwareTester::refreshSineWave()
{
Wavetable wavetable_;
wavetable_ = Wavetable(WAVE_LEN);
for(unsigned char i=0;i<WAVE_LEN;++i)
{
wavetable_.setSample(i,sine_wave[i]);
}
audio_->pasteWavetable(wavetable_);
}
void AteOscHardwareTester::poll(unsigned char ticksPassed)
{
static unsigned char waveIndex = 0;
static unsigned char waveTick = 0;
unsigned char waveLed = 0;
if(allIpLedsZero() && audio_->getSampleFreq()!= TESTFREQ_AUDIO)
{
audio_->setSampleFreq(TESTFREQ_AUDIO);
hardware_.setAudioBufferStatus(AteOscHardware::BUFFER_WAITZCROSS);
clearLeds();
}
if(!allIpLedsZero() && audio_->getSampleFreq()!= WAVE_LEN)
{
audio_->setSampleFreq(WAVE_LEN);
clearLeds();
}
hardware_.pollCvInputs(ticksPassed);
hardware_.pollAudioBufferStatus();
if (allIpLedsZero())
{
waveTick += ticksPassed;
if(waveTick>31)
{
waveTick -= 32;
waveLed = (hardware_.getAudioBuffer(waveIndex) + 128) >> 4;
hardware_.getLedCircular(AteOscHardware::FUNCTION).select(((unsigned int)waveIndex<<3) / (hardware_.getAudioBufferLength()+1));
hardware_.getLedCircular(AteOscHardware::VALUE).select(waveLed);
waveIndex++;
if(waveIndex>hardware_.getAudioBufferLength())
{
waveIndex = 0;
hardware_.setAudioBufferStatus(AteOscHardware::BUFFER_WAITZCROSS);
}
}
}
else
{
hardware_.setAudioBufferStatus(AteOscHardware::BUFFER_WAITZCROSS);
}
hardware_.refreshFlash(ticksPassed);
hardware_.refreshLeds();
}
bool AteOscHardwareTester::allIpLedsZero()
{
for(unsigned char i=0;i<AteOscHardware::CV_INPUTS;++i)
{
if(ipLed_[i]>0)
{
return false;
}
}
return true;
}
//***************** Hardware Events *******************************************
void AteOscHardwareTester::hardwareCvInputChanged(unsigned char control, unsigned int newValue)
{
unsigned char newLed = newValue >> 8;
if(newLed!=ipLed_[control])
{
ipLed_[control] = newLed;
hardware_.getLedCircular(AteOscHardware::VALUE).fill(newLed);
if(newLed>0)
{
hardware_.getLedCircular(AteOscHardware::FUNCTION).setSegment(control,true);
}
else
{
hardware_.getLedCircular(AteOscHardware::FUNCTION).setSegment(control,false);
}
}
}
void AteOscHardwareTester::hardwareSwitchChanged(unsigned char sw, unsigned char newValue)
{
}
void AteOscHardwareTester::hardwareSwitchHeld(unsigned char sw)
{
}
void AteOscHardwareTester::hardwareRotaryEncoderChanged(unsigned char rotary, unsigned char newValue, bool clockwise)
{
}
void AteOscHardwareTester::hardwareAudioBufferStatusChanged(unsigned char newStatus)
{
}
#else
//**** NORMAL HARDWARE TESTER**********************************************************************************************
void AteOscHardwareTester::init()
{
wavetable_ = Wavetable(WAVE_LEN);
audio_->initialize();
refreshSineWave();
//Serial.begin(9600);
}
void AteOscHardwareTester::initMemory()
{
unsigned int addr = 0;
unsigned char framBuffer[OSC_WAVELEN] = {0};
unsigned char eepromBuffer[PATCH_SIZE] = {0};
unsigned char i,j,k;
for(i=0;i<2;++i)
{
hardware_.getLedCircular(i).setState(0);
hardware_.getLedSwitch(i).setColour(LedRgb::OFF);
}
hardware_.refreshLeds();
//init fram
hardware_.getLedSwitch(AteOscHardware::FUNCTION).setColour(LedRgb::YELLOW);
hardware_.refreshLeds();
for(i=0;i<OSC_BANKS;++i)
{
hardware_.getLedCircular(AteOscHardware::FUNCTION).select(i);
for (j=0;j<OSC_TABLES;++j)
{
hardware_.getLedCircular(AteOscHardware::VALUE).select(j);
hardware_.refreshLeds();
for(k=0;k<OSC_WAVELEN;++k)
{
framBuffer[k] = pgm_read_byte(&(OSC_WAVETABLE[i][j][k]));
}
writeFram((const void*)framBuffer, addr, sizeof(framBuffer));
readFram((void*)framBuffer, addr, sizeof(framBuffer));
for(k=0;k<OSC_WAVELEN;++k)
{
if(framBuffer[k]!=pgm_read_byte(&(OSC_WAVETABLE[i][j][k])))
{
hardware_.getLedSwitch(AteOscHardware::FUNCTION).setColour(LedRgb::RED);
hardware_.refreshLeds();
for(;;){} //STOP
}
}
addr += OSC_WAVELEN;
}
}
hardware_.getLedSwitch(AteOscHardware::FUNCTION).setColour(LedRgb::GREEN);
//init eeprom
hardware_.getLedSwitch(AteOscHardware::VALUE).setColour(LedRgb::YELLOW);
hardware_.refreshLeds();
addr = 0;
hardware_.getLedCircular(AteOscHardware::FUNCTION).select(0);
for(i=0;i<PATCHES;++i)
{
hardware_.getLedCircular(AteOscHardware::VALUE).select(i);
hardware_.refreshLeds();
for(j=0;j<PATCH_SIZE;++j)
{
eepromBuffer[j] = pgm_read_byte(&(PATCH_DATA[i][j]));
}
writeMemory((const void*)eepromBuffer, (void*)addr, sizeof(eepromBuffer));
readMemory((void*)eepromBuffer,(const void*)addr, sizeof(eepromBuffer));
for(j=0;j<PATCH_SIZE;++j)
{
if(eepromBuffer[j]!=pgm_read_byte(&(PATCH_DATA[i][j])))
{
hardware_.getLedSwitch(AteOscHardware::FUNCTION).setColour(LedRgb::RED);
hardware_.refreshLeds();
for(;;){} //STOP
}
}
addr += PATCH_SIZE;
}
hardware_.getLedSwitch(AteOscHardware::VALUE).setColour(LedRgb::GREEN);
hardware_.getLedCircular(AteOscHardware::FUNCTION).select(1);
hardware_.refreshLeds();
//global settings
hardware_.writeEepromByte(AteOscHardware::EEPROM_CURRENT_PATCH, 0);
hardware_.writeEepromByte(AteOscHardware::EEPROM_CTRL_MODE, 0);
hardware_.writeEepromByte(AteOscHardware::EEPROM_CLOCK_MODE, 0);
hardware_.writeEepromByte(AteOscHardware::EEPROM_QUANT_KEY, 0);
//stick zeros in for all of this so don't think it's calibrated when it isn't
hardware_.writeEepromByte(AteOscHardware::EEPROM_PITCH_LOW, 0x00); //1024 1.25V 77.8Hz msb
hardware_.writeEepromByte(AteOscHardware::EEPROM_PITCH_LOW+1, 0x00); //1024 1.25V 77.8Hz lsb
hardware_.writeEepromByte(AteOscHardware::EEPROM_PITCH_HIGH, 0x00); //3072 3.75V 440Hz msb
hardware_.writeEepromByte(AteOscHardware::EEPROM_PITCH_HIGH+1, 0x00); //3072 3.75V 440Hz lsb
hardware_.writeEepromByte(AteOscHardware::EEPROM_FILT_LOW, 0x00); //1024 1.25V 77.8Hz msb
hardware_.writeEepromByte(AteOscHardware::EEPROM_FILT_LOW+1, 0x00); //1024 1.25V 77.8Hz lsb
hardware_.writeEepromByte(AteOscHardware::EEPROM_FILT_HIGH, 0x00); //3072 3.75V 440Hz msb
hardware_.writeEepromByte(AteOscHardware::EEPROM_FILT_HIGH+1, 0x00); //3072 3.75V 440Hz lsb
//
for(i=0;i<2;++i)
{
hardware_.getLedCircular(i).setState(0);
hardware_.getLedSwitch(i).setColour(LedRgb::OFF);
}
hardware_.refreshLeds();
}
void AteOscHardwareTester::refreshAudioTest()
{
//hardware_.getLedCircular(AteOscHardware::VALUE).select(hardware_.getAudioCurrent()>>4); //no longer exists, would involve a volatile global variable
if(hardware_.getAudioBufferStatus()==AteOscHardware::BUFFER_CAPTURED)
{
//see excel sheet for proof of this interpolation
unsigned int pos = 0;
unsigned int jump = (unsigned int)hardware_.getAudioBufferLength() << 1; //0-255
for(unsigned char i=0;i<WAVE_LEN;++i)
{
wavetable_.setSample(i,hardware_.getAudioBuffer(pos >> 8));
pos += jump;
}
audio_->pasteWavetable(wavetable_);
hardware_.setAudioBufferStatus(AteOscHardware::BUFFER_IDLE);
}
}
void AteOscHardwareTester::refreshSineWave()
{
for(unsigned char i=0;i<WAVE_LEN;++i)
{
wavetable_.setSample(i,saw_wave[i]);
}
audio_->pasteWavetable(wavetable_);
}
void AteOscHardwareTester::tick()
{
unsigned char i;
if(test_==TEST_TICK)
{
hardware_.getLedCircular(0).select(tick_%8);
hardware_.getLedCircular(1).select(tick_);
for(i=0;i<2;++i)
{
if(tick_%2==0)
{
hardware_.getLedSwitch(i).setColour(LedRgb::RED);
}
else
{
hardware_.getLedSwitch(i).setColour(LedRgb::GREEN);
}
}
tick_++;
if(tick_>15)
{
tick_ = 0;
}
}
}
void AteOscHardwareTester::poll(unsigned char ticksPassed)
{
static unsigned char waveIndex = 0;
static unsigned char waveTick = 0;
unsigned char waveLed = 0;
hardware_.pollSwitches(ticksPassed);
hardware_.pollRotEncoders(ticksPassed);
hardware_.pollCvInputs(ticksPassed);
hardware_.pollAudioBufferStatus();
if(test_==TEST_POTS)
{
for(unsigned char i=0;i<8;++i)
{
if(hardware_.getCvInput(i).getMoving()!=lastMoving_[i])
{
lastMoving_[i] = hardware_.getCvInput(i).getMoving();
if(lastMoving_[i]==true)
{
hardware_.getLedCircular(0).setSegment(i,true);
}
else
{
hardware_.getLedCircular(0).setSegment(i,false);
}
}
//Serial.print(hardware_.getCvInput(i).getValue(),DEC);
//Serial.print("\t");
}
//Serial.println("");
}
if(test_==TEST_AUDIO)
{
refreshAudioTest();
waveTick += ticksPassed;
if(waveTick>7)
{
waveTick -= 8;
waveLed = (hardware_.getAudioBuffer(waveIndex) + 128) >> 4;
hardware_.getLedCircular(AteOscHardware::FUNCTION).select(waveIndex>>5);
hardware_.getLedCircular(AteOscHardware::VALUE).select(waveLed);
waveIndex++;
if(waveIndex>hardware_.getAudioBufferLength())
{
waveIndex = 0;
}
}
}
audio_->setSampleFreq((unsigned long)pitch_.calcFrequency(pitch_.getOutput()) * (WAVE_LEN>>2));
hardware_.refreshFlash(ticksPassed);
hardware_.refreshLeds();
}
//***************** Hardware Events *******************************************
void AteOscHardwareTester::hardwareCvInputChanged(unsigned char control, unsigned int newValue)
{
if(test_==TEST_POTS && !(control==AteOscHardware::CV_PITCH || control==AteOscHardware::CV_FILT))
{
hardware_.getLedCircular(AteOscHardware::VALUE).fill(newValue>>8);
}
if(control==AteOscHardware::CV_PITCHPOT) //2 = pitch knob
{
pitch_.setCoarseOffset(newValue<<1);
}
if(control==AteOscHardware::CV_PITCH)
{
pitch_.setInput((newValue * 15)>>4);
}
}
void AteOscHardwareTester::hardwareSwitchChanged(unsigned char sw, unsigned char newValue)
{
unsigned char i;
static unsigned char lastLed = 255;
unsigned char curLed = 0;
if(newValue==HIGH)
{
for(i=0;i<2;++i)
{
hardware_.getLedCircular(i).setState(0);
hardware_.getLedSwitch(i).setColour(LedRgb::OFF);
}
hardware_.getLedSwitch(sw).setColour(LedRgb::YELLOW);
if(sw==AteOscHardware::FUNCTION)
{
if(test_==TEST_TICK)
{
test_ = TEST_POTS;
refreshSineWave();
}
else
{
test_ = TEST_TICK;
}
}
else
{
test_ = TEST_AUDIO;
hardware_.setAudioBufferStatus(AteOscHardware::BUFFER_WAITZCROSS);
}
}
}
void AteOscHardwareTester::hardwareSwitchHeld(unsigned char sw)
{
if(test_==TEST_POTS)
{
hardware_.getLedSwitch(sw).setColour(LedRgb::YELLOW);
switch(hardware_.getRotEncoder(AteOscHardware::FUNCTION).getValue())
{
case 0:
//hardware_.setCvCalib(AteOscHardware::EEPROM_PITCH_LOW);
break;
case 1:
//hardware_.setCvCalib(AteOscHardware::EEPROM_PITCH_HIGH);
break;
case 2:
//hardware_.setCvCalib(AteOscHardware::EEPROM_FILT_LOW);
break;
case 3:
//hardware_.setCvCalib(AteOscHardware::EEPROM_FILT_HIGH);
break;
}
}
}
void AteOscHardwareTester::hardwareRotaryEncoderChanged(unsigned char rotary, unsigned char newValue, bool clockwise)
{
if(test_==TEST_POTS)
{
hardware_.getLedCircular(rotary).select(newValue);
}
}
void AteOscHardwareTester::hardwareAudioBufferStatusChanged(unsigned char newStatus)
{
if(test_==TEST_AUDIO)
{
switch (newStatus)
{
case AteOscHardware::BUFFER_IDLE:
hardware_.getLedSwitch(AteOscHardware::VALUE).setColour(LedRgb::OFF);
break;
case AteOscHardware::BUFFER_WAITZCROSS:
hardware_.getLedSwitch(AteOscHardware::VALUE).setColour(LedRgb::YELLOW);
break;
case AteOscHardware::BUFFER_CAPTURING:
hardware_.getLedSwitch(AteOscHardware::VALUE).setColour(LedRgb::RED);
break;
case AteOscHardware::BUFFER_OVERFLOW:
hardware_.getLedSwitch(AteOscHardware::FUNCTION).setColour(LedRgb::RED);
hardware_.getLedSwitch(AteOscHardware::VALUE).setColour(LedRgb::OFF);
break;
case AteOscHardware::BUFFER_CAPTURED:
hardware_.getLedSwitch(AteOscHardware::FUNCTION).setColour(LedRgb::GREEN);
hardware_.getLedSwitch(AteOscHardware::VALUE).setColour(LedRgb::OFF);
break;
}
}
}
#endif
| [
"info@soulsbysynths.com"
] | info@soulsbysynths.com |
dc4452145ff40469f975c33d50249778f283139c | aa1303ca3a7f9da73c53d0d162b901f1cf4486a1 | /0105/0105.ino | 814bddcc0e1c536bdd7dd9a67827ec45278e6823 | [] | no_license | toh4578603/0105 | acc949d1fea7ae9d2ed1ee72d6d6658315bf4534 | 3100394d0c273dd31c663ae8e04e844943c7a971 | refs/heads/main | 2023-02-10T19:29:48.596606 | 2021-01-05T01:20:44 | 2021-01-05T01:20:44 | 326,850,895 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 394 | ino | void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
}
void loop() {
// put your main code here, to run repeatedly:
int x =analogRead(A1);
int y =analogRead(A2);
int z =analogRead(A3);
Serial.println("X Y Z");
Serial.print(x);
Serial.print(" ");
Serial.print(y);
Serial.print(" ");
Serial.println(z);
delay(1500);
}
| [
"noreply@github.com"
] | noreply@github.com |
284422c941f21525c9cfa3e18cbf903b7ede4ab1 | f986f173065c6a8bdd7f61d6ce25101553570499 | /BP_init.cpp | 92a54cea0899c314443f7293ea470a5a718af914 | [] | no_license | jfbaer/MinimalResolution | fe6f4d14999ab22cf2a070260e07cfce8e4449e4 | 3006529b9c4cad41715bf46ff749263c60441889 | refs/heads/master | 2023-04-23T10:39:30.426695 | 2020-06-17T02:22:06 | 2020-06-17T02:22:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,394 | cpp | //BP_init.cpp
#include"BP_init.h"
//initialize a generic comodule
BPComodInit::BPComodInit(string filename) : BPCoMod_generic(&coaction_matrix), coaction_matrix(filename){
}
//the constructor
BPInit::BPInit(int max_deg, int res_length, string etaL_data, string delta_data, string R2L_data, string dirname) : BP_oper(max_deg, &Z2_oper, &etaL_matrix, &delta_matrix, &R2L_matrix), F2Mod_opers(&Z2_oper.F2_opers), etaL_matrix(dirname + "etaL_matrix"), R2L_matrix(dirname + "R2L_matrix"), delta_matrix(dirname + "delta_matrix"), indj(dirname + "indj"), qut(dirname + "qut"), new_map(dirname + "new_map"), mm(dirname + "mm_matrix"), comod(dirname + "comodule_matrix"), multp(&BP_oper){
max_degree = max_deg;
resolution_length = res_length;
director = dirname;
//initialize matric operators
matrix<BP>::moduleOper = &BP_oper.BPMod_opers;
matrix<BPBP>::moduleOper = &BP_oper.BPBPMod_opers;
matrix<Z2>::moduleOper = &BP_oper.Z2Mod_opers;
//initialize the structure data
BP_oper.initialize(etaL_data, delta_data, R2L_data);
//initialize the comod to a trivial one with one generator at degree 0
BP_oper.set_to_trivial(comod,0);
//initialize the curtis tables
curtis_table<F2>::ModOper = &F2Mod_opers;
ResolutionTables.resize(resolution_length+2);
//set the complex of primitives
primitive_data::set_oper(&BP_oper);
//set the algebraic Novikov table
algNov_table::set_op(&BP_oper);
AAN_table.resize(resolution_length+1);
AANtables.set_table(&AAN_table);
//set the Bockstein table
B_table.resize(res_length+1);
Btables.set_table(&B_table);
}
//do resolutions
void BPInit::resolve(){
std::function<curtis_table<F2>*(int)> tables = [this](int i){
return &ResolutionTables[i]; };
std::function<vectors<matrix_index,BP>(const vectors<matrix_index,Fp>&)> tfm = [this] (const vectors<matrix_index,Fp>& v){
return BP_oper.lift(v); };
BP_oper.pre_resolution_modeled(comod, director + "maps", director + "gens", resolution_length, director+"tables", &ctable, gens, tfm, &inj, &qut, &indj, &new_map, director + "back");
//combining generator files
BP_oper.gens_file_combiner(director + "gens", resolution_length, comod);
}
//construct resolution
void BPInit::resolution(){
//construct the resolution
std::fstream outfile("maps.txt", std::ios::out);
BP_oper.resolution(director + "maps", director + "gens", director + "res" , resolution_length, comod, &inj, &qut, &indj, NULL);
//set the matrices
mapses.resize(resolution_length + 2);
std::function <matrix<Z2>*(int)> mst = [this](int i){
return &mapses[i]; };
//construct the complex of primitives
Complex.load(resolution_length,director + "gens",director + "res",&inj,&indj,mst);
Complex.save_matrix(director + "cpx");
}
//load the curtis table data
void BPInit::loadResolutionTables(string table_data){
std::fstream tables(table_data, std::ios::in | std::ios::binary);
std::cout << tables.is_open() << std::flush;
for(unsigned i=0; i<ResolutionTables.size(); ++i){
ResolutionTables[i].load(tables);
std::cout << ResolutionTables[i].output();
}
}
//load the data for generators
void BPInit::load_gens(string gens_data){
std::fstream genfile(gens_data, std::ios::in | std::ios::binary);
std::cout << genfile.is_open() << std::flush;
int32_t sz;
genfile.read((char*)&sz, 4);
gens.resize(sz);
for(int i=0; i<sz; ++i){
int32_t ss;
genfile.read((char*)&ss, 4);
gens[i].resize(ss);
for(int j=0; j<ss; ++j)
genfile.read((char*)&gens[i][j], 4);
}
}
//make algebraic Novikov table
void BPInit::make_algNov(){
Complex.load_matrix(resolution_length,director + "gens", director+"cpx");
AANtables.table_of_complex(Complex,resolution_length);
AANtables.save(director + "AANSS_table_binary");
std::fstream atb(director + "AANSS_table.txt", std::ios::out);
atb << AANtables.output_tables();
auto et2 = multp.two_extension(resolution_length,Complex,AANtables,resolution_length);
std::fstream h0f(director + "AANSS_h0.txt", std::ios::out);
h0f << multp.output_multiplication_table(et2,0,resolution_length-1);
}
//make Bockstein table
void BPInit::make_Boc(){
Complex.load_matrix(resolution_length,director + "gens", director+"cpx");
Btables.table_of_complex(Complex,resolution_length);
Btables.save(director + "BocSS_table_binary");
std::fstream btb(director + "BocSS_table.txt", std::ios::out);
btb << Btables.output_tables();
auto ba = Btables.Bname2Anames(resolution_length, AANtables, resolution_length);
std::fstream b2a(director + "B2A_table.txt", std::ios::out);
b2a << multp.output_multiplication_table(ba,0,resolution_length-1);
}
//make the algebraic Novikov multiplication table by a given element in BPBP
void BPInit::mult_table(BPBP const &mul, int deg, string filename){
//load the complex
auto genst = BPComplex::get_generator(resolution_length, director + "gens");
//load the complex of primitives
Complex.load_matrix(resolution_length, director +"gens", director + "cpx");
//load the algebraic Novikov table
AANtables.load(director + "AANSS_table_binary");
Btables.load(director + "BocSS_table_binary");
//make the multiplication table on BPBP
multp.make_eta_R_multiplier(mul, &inj, deg);
//compute the table for the multiplication on algebraic Novikov spectral sequence
auto multable = multp.mult_extension(&inj, max_degree-deg, resolution_length, genst, director + "res", Complex, AANtables, &indj, &mm, resolution_length);
//output the table
std::fstream file(director + "AANSS_" + filename, std::ios::out);
file << multp.output_multiplication_table(multable, 1, resolution_length-2);
//compute the table for the multiplication on Bockstein spectral sequence
auto Bmultable = multp.mult_extension(&inj, max_degree-deg, resolution_length, genst, director + "res", Complex, Btables, &indj, &mm, resolution_length);
//output the table
std::fstream fileB(director + "BocSS_" + filename, std::ios::out);
fileB << multp.output_multiplication_table(Bmultable, 1, resolution_length-2);
}
//make multiplication table for top theta on the Moore spectrum
void BPInit::mult_theta(){
//load the complex
auto genst = BPComplex::get_generator(resolution_length, director + "gens");
//load the complex of primitives
Complex.load_matrix(resolution_length, director +"gens", director + "cpx");
//load the algebraic Novikov table
AANtables.load(director + "AANSS_table_binary");
Btables.load(director + "BocSS_table_binary");
//compute the top thetas
auto theta = BP_oper.thetas();
//degree of theta
int deg = 2;
for(int i=2; i<=5; ++i){
deg *= 2;
//make the multiplication table on BPBP
multp.make_eta_R_multiplier(theta[i], &inj, deg);
//compute the table for the multiplication on Bockstein spectral sequence
auto Bmultable = multp.mult_extension(&inj, max_degree-deg, resolution_length, genst, director + "res", Complex, Btables, &indj, &mm, 1, true);
//output the table
std::fstream fileB(director + "BocSS_theta" + std::to_string(i) + ".txt", std::ios::out);
fileB << multp.output_multiplication_table(Bmultable, 1, 10);
}
}
//make the algebraic Novikov multiplication table by a given element in BPBP
void BPInit::mult_table(){
//make the h1 multiplication table
BPBP h1 = BP_oper.h1();
mult_table(h1, 1, "h1.txt");
//make h2 multiplication table
BPBP h2 = BP_oper.h2();
mult_table(h2, 2, "h2.txt");
//make h3 multiplication table
BPBP h3 = BP_oper.h3();
mult_table(h3, 4, "h3.txt");
}
| [
"noreply@github.com"
] | noreply@github.com |
ba7bb88db9e99a1a4c0e4607cc0fe77272963c6c | 3c0da20114e7efaab1d06e1da06d07f7e550a5e1 | /1204.cpp | 4d5c170ab3c70cd35aa2df2907b5200fcaf3edec | [] | no_license | Accelerator950113/Solutions_For_HDU | 5cf91fbfd185463edc573ba582f4482c6669c9eb | f8711f27f4e05aa089426b1c87236ba919eaca74 | refs/heads/master | 2021-09-09T00:45:03.462143 | 2018-03-13T01:56:05 | 2018-03-13T01:56:05 | 115,673,240 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,428 | cpp | #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <bitset>
#include <sstream>
using namespace std;
int n, m;
int N;
double p, q;
double p1, p2, p3;
double a[128][128], b[128][128];
void show() {
for (int i = 0; i <= N; ++ i) {
for (int j = 0; j <= N; ++ j)
printf("%.2lf ", a[i][j]);
printf("\n");
}
printf("\n");
}
int main() {
while (scanf("%d%d%lf%lf", &n, &m, &p, &q) == 4) {
if (n == 0) {
puts("0.00");
continue;
}
if (m == 0) {
puts("1.00");
continue;
}
p1 = p - p*q;
p2 = q - p*q;
p3 = 1 - p - q + 2*p*q;
N = n+m;
for (int i = 0; i <= N; ++ i)
for (int j = 0; j <= N; ++ j)
a[i][j] = 0;
for (int i = 2; i <= N-2; ++ i)
a[i-1][i] = p1, a[i][i] = p3, a[i+1][i] = p2;
a[1][0] = p2;
a[2][1] = p2, a[1][1] = p3;
a[N-1][N] = p1;
a[N-2][N-1] = p1, a[N-1][N-1] = p3;
a[0][0] = 1, a[N][N] = 1;
if (N == 2)
a[2][1] = a[0][1] = 0;
//show();
for (int cs = 0; cs < 32; ++ cs) {
for (int i = 0; i <= N; ++ i)
for (int j = 0; j <= N; ++ j) {
b[i][j] = 0;
for (int k = 0; k <= N; ++ k)
b[i][j] += (a[i][k] * a[k][j]);
}
for (int i = 0; i <= N; ++ i)
for (int j = 0; j <= N; ++ j)
a[i][j] = b[i][j];
}
//show();
printf("%.2lf\n", a[n][N]);
}
return 0;
} | [
"13307130144@fudan.edu.cn"
] | 13307130144@fudan.edu.cn |
dd2b32e8b81e1bfff391abd88893f0946d968559 | ea3bfc8f56655965e2da7e07d1facefef02df7cc | /other/diverta_c.cpp | 13159578be2fcf215170204c810318b72544dc45 | [] | no_license | yyamada12/atCoder | d6ce460aa5e0f49566ef60b03def39c918077c48 | 465a537df5df4aedb58af98bc723fc077ca6417c | refs/heads/master | 2020-05-16T14:14:29.655832 | 2019-08-21T13:57:00 | 2019-08-21T13:57:00 | 183,096,981 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,719 | cpp | #include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;
#define REP(i,n) for(int i = 0; i < n; i++)
#define RREP(i,n) for(int i = n - 1; i >= 0; i--)
#define ALL(v) v.begin(),v.end()
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define UNIQUE(v) do{sort(v.begin(), v.end()); v.erase( unique(v.begin(), v.end()), v.end() );} while(0)
#define y0 y3487465
#define y1 y8687969
#define m0(x) memset(x,0,sizeof(x))
#define m1(x) memset(x,63,sizeof(x))
typedef long long ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pi> vpi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
double EPS = 1e-9;
int INFi = 1000000005;
long long INFll = 1000000000000000005ll;
double PI = acos(-1);
int dirx[8] = {-1,0,0,1,-1,-1,1,1};
int diry[8] = {0,1,-1,0,-1,1,-1,1};
ll MOD = 1000000007;
ll N;
const ll MAX_N = 10000;
string s[MAX_N];
int main(){
cin >> N;
REP(i, N) cin >> s[i];
ll numa = 0, numb = 0, numab = 0;
REP(i, N) {
if(s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
numab++;
} else if(s[i][0] == 'B') {
numb++;
} else if(s[i][s[i].size() - 1] == 'A') {
numa++;
}
}
ll num = 0;
REP(i, N) {
REP(j, s[i].size() - 1) {
if(s[i][j] == 'A' && s[i][j + 1] == 'B') {
num++;
}
}
}
ll m = min(numa, numb);
if(m > 0) {
cout << numab + m + num << endl;
} else if(numa == numb && numab > 0) {
cout << numab - 1 + num << endl;
} else {
cout << numab + num << endl;
}
return 0;
}
| [
"12yacropolisy@gmail.com"
] | 12yacropolisy@gmail.com |
979b58343c32f2aad6a4977741d75f058534fb13 | 2d5a651995ca6ba53b169b5e58ef75159715e886 | /Source/Core/Image/HCLColor.cpp | 55d52f95c5690b0d05f79365208f815a631c93f4 | [
"BSD-3-Clause"
] | permissive | GoTamura/KVS | 4a4aabd5dac5c5362b7404f4d9b50ae33bb0cbb6 | 121ede0b9b81da56e9ea698a45ccfd71ff64ed41 | refs/heads/develop | 2021-06-12T05:27:34.959934 | 2019-04-11T23:57:26 | 2019-04-11T23:57:26 | 181,405,935 | 0 | 0 | BSD-3-Clause | 2019-04-15T03:29:11 | 2019-04-15T03:29:09 | null | UTF-8 | C++ | false | false | 2,809 | cpp | /*****************************************************************************/
/**
* @file HCLColor.cpp
* @author Naohisa Sakamoto
*/
/*----------------------------------------------------------------------------
*
* $Id$
*/
/*****************************************************************************/
#include "HCLColor.h"
#include <kvs/LabColor>
#include <kvs/Math>
#include <cmath>
namespace
{
inline kvs::Real32 Rad2Deg( const kvs::Real32 rad )
{
kvs::Real32 deg = 0.0f;
if ( rad > 0.0f )
{
deg = ( rad / kvs::Math::PI() ) * 180.0f;
}
else
{
deg = 360.0f - ( kvs::Math::Abs( rad ) / kvs::Math::PI() ) * 180.0f;
}
return deg;
}
inline kvs::Real32 Deg( const kvs::Real32 deg )
{
if ( deg < 0.0f ) { return deg + 360.0f; }
else if ( deg >= 360.0f ) { return deg - 360.0f; }
else { return deg; }
}
inline kvs::HCLColor Lab2HCL( const kvs::LabColor& lab )
{
const kvs::Real32 l = lab.l();
const kvs::Real32 c = std::sqrt( lab.a() * lab.a() + lab.b() * lab.b() );
const kvs::Real32 h = Deg( Rad2Deg( std::atan2( lab.b(), lab.a() ) ) );
return kvs::HCLColor( h, c, l );
}
inline kvs::LabColor HCL2Lab( const kvs::HCLColor& hcl )
{
const kvs::Real32 l = hcl.l();
const kvs::Real32 theta = hcl.h() * 2.0f * kvs::Math::PI();
const kvs::Real32 a = std::cos( theta ) * hcl.c();
const kvs::Real32 b = std::sin( theta ) * hcl.c();
return kvs::LabColor( l, a, b );
}
}
namespace kvs
{
HCLColor::HCLColor( kvs::Real32 h, kvs::Real32 c, kvs::Real32 l ):
m_h( h ),
m_c( c ),
m_l( l )
{
}
HCLColor::HCLColor( const kvs::Vec3& hcl ):
m_h( hcl[0] ),
m_c( hcl[1] ),
m_l( hcl[2] )
{
}
HCLColor::HCLColor( const kvs::LabColor& lab )
{
*this = ::Lab2HCL( lab );
}
kvs::LabColor HCLColor::toLabColor() const
{
return ::HCL2Lab( *this );
}
kvs::HCLColor& HCLColor::operator += ( const kvs::HCLColor& hcl )
{
m_h += hcl.h();
m_c += hcl.c();
m_l += hcl.l();
return *this;
}
kvs::HCLColor& HCLColor::operator -= ( const kvs::HCLColor& hcl )
{
m_h -= hcl.h();
m_c -= hcl.c();
m_l -= hcl.l();
return *this;
}
kvs::HCLColor& HCLColor::operator = ( const kvs::HCLColor& hcl )
{
m_h = hcl.h();
m_c = hcl.c();
m_l = hcl.l();
return *this;
}
kvs::HCLColor& HCLColor::operator = ( const kvs::LabColor& lab )
{
*this = ::Lab2HCL( lab );
return *this;
}
kvs::HCLColor operator + ( const kvs::HCLColor& a, const kvs::HCLColor& b )
{
kvs::HCLColor ret( a ); ret += b;
return ret;
}
bool operator == ( const kvs::HCLColor& a, const kvs::HCLColor& b )
{
return
kvs::Math::Equal( a.h(), b.h() ) &&
kvs::Math::Equal( a.c(), b.c() ) &&
kvs::Math::Equal( a.l(), b.l() );
}
} // end of namespace kvs
| [
"naohisa.sakamoto@gmail.com"
] | naohisa.sakamoto@gmail.com |
2ef42e2a67d1c1df67734ba97aa9fd6939cf4b30 | 427b820b23a8a41efdfd0ce9254d0d381ee4e7dc | /wallet/hw_wallet.h | 7cbb0e22f1215c067b12de8a15f5439a94eae703 | [
"Apache-2.0"
] | permissive | coincashbank/beam | 85a24e508bc6f9eaa7de425b4b7ca5a04e9925cb | 23de04767700a719656bf91a6f5a46663540bc6a | refs/heads/master | 2020-07-11T20:09:26.864209 | 2019-08-26T13:46:34 | 2019-08-26T14:08:36 | 204,634,172 | 0 | 1 | Apache-2.0 | 2019-08-27T09:23:55 | 2019-08-27T06:23:55 | null | UTF-8 | C++ | false | false | 2,317 | h | // Copyright 2018 The Beam Team
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include "core/common.h"
#include "core/ecc.h"
#include "core/ecc_native.h"
#include "core/block_crypt.h"
namespace beam
{
class HWWalletImpl;
class HWWallet
{
public:
HWWallet();
template<typename T> using Result = std::function<void(const T& key)>;
struct TxData
{
beam::HeightRange height;
beam::Amount fee;
ECC::Point kernelCommitment;
ECC::Point kernelNonce;
uint32_t nonceSlot;
ECC::Scalar offset;
};
void getOwnerKey(Result<std::string> callback) const;
void generateNonce(uint8_t slot, Result<ECC::Point> callback) const;
void getNoncePublic(uint8_t slot, Result<ECC::Point> callback) const;
void generateKey(const ECC::Key::IDV& idv, bool isCoinKey, Result<ECC::Point> callback) const;
void generateRangeProof(const ECC::Key::IDV& idv, bool isCoinKey, Result<ECC::RangeProof::Confidential> callback) const;
void signTransaction(const std::vector<Key::IDV>& inputs, const std::vector<Key::IDV>& outputs, const TxData& tx, Result<ECC::Scalar> callback) const;
std::string getOwnerKeySync() const;
ECC::Point generateNonceSync(uint8_t slot) const;
ECC::Point getNoncePublicSync(uint8_t slot) const;
ECC::Point generateKeySync(const ECC::Key::IDV& idv, bool isCoinKey) const;
ECC::RangeProof::Confidential generateRangeProofSync(const ECC::Key::IDV& idv, bool isCoinKey) const;
ECC::Scalar signTransactionSync(const std::vector<Key::IDV>& inputs, const std::vector<Key::IDV>& outputs, const TxData& tx) const;
private:
std::shared_ptr<HWWalletImpl> m_impl;
};
} | [
"vadim@beam-mw.com"
] | vadim@beam-mw.com |
ed02569611501320f78495857fce6da319577045 | bfdb43cafb522c73bb15e661fa9d319bf9706894 | /Source/UnRLGym/UnRLGym.cpp | 5b327fdb313f52c90fc2b6200642afe9ea24f6c4 | [] | no_license | tetorea/UnRLGym | dd8aa8f0f070879d57a8e422214bc1325c606243 | a560bc1e7715e780a50286f3b2d86bbbdbf49047 | refs/heads/master | 2023-05-28T01:04:08.796547 | 2021-06-15T07:58:40 | 2021-06-15T07:58:40 | 330,598,325 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 214 | cpp | // Fill out your copyright notice in the Description page of Project Settings.
#include "UnRLGym.h"
#include "Modules/ModuleManager.h"
IMPLEMENT_PRIMARY_GAME_MODULE( FDefaultGameModuleImpl, UnRLGym, "UnRLGym" );
| [
"tetorea@gmail.com"
] | tetorea@gmail.com |
e35d3205eae942d9a21243905a0aca8f9a858bd1 | e577e0df9206da79cc63b6b2d18af42493cd3df9 | /menu/input/input.h | 5bf80bfe91f7cc8e053577cb868a49887eaefcd8 | [] | no_license | Akatsyk/2k17-club | 042e2e068328ce1845592141f8e3722dd3c749b1 | 99ab6cedab34af93602e1fbcc68078b79af9f7a0 | refs/heads/main | 2023-08-18T15:44:52.464557 | 2021-09-25T13:51:04 | 2021-09-25T13:51:04 | 410,284,639 | 8 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 526 | h | #pragma once
#include "Windows.h"
#include "../../sdk.hpp"
class input {
public:
void wndproc( UINT message, WPARAM wparam, LPARAM lparam );
virtual bool inbounds( const Vector2D& pos, const Vector2D& pos2 );
void pre();
Vector2D mouse_pos;
Vector2D get_pos( ) const { return mouse_pos; };
void think( );
bool is_key_down( int key );
bool is_key_pressed( int key );
bool is_key_released( int key );
int scroll_amount;
private:
bool previous_key_state[ 256 ];
bool tabbed_out;
};
extern input g_menuinput; | [
"48151096+Akatsyk@users.noreply.github.com"
] | 48151096+Akatsyk@users.noreply.github.com |
c2687a350b8eae51043e04077aa5c9d3eb98464f | 5456502f97627278cbd6e16d002d50f1de3da7bb | /extensions/browser/api/display_source/display_source_apitest.cc | c24bf013ad53a2c645fb35310c7e5e720dd5c9cf | [
"BSD-3-Clause"
] | permissive | TrellixVulnTeam/Chromium_7C66 | 72d108a413909eb3bd36c73a6c2f98de1573b6e5 | c8649ab2a0f5a747369ed50351209a42f59672ee | refs/heads/master | 2023-03-16T12:51:40.231959 | 2017-12-20T10:38:26 | 2017-12-20T10:38:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 823 | cc | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "extensions/browser/api/display_source/display_source_apitestbase.h"
#include "extensions/shell/test/shell_apitest.h"
namespace extensions {
class DisplaySourceApiTest : public ShellApiTest {
public:
DisplaySourceApiTest() = default;
private:
void SetUpOnMainThread() override {
ShellApiTest::SetUpOnMainThread();
InitMockDisplaySourceConnectionDelegate(browser_context());
content::RunAllPendingInMessageLoop();
}
};
IN_PROC_BROWSER_TEST_F(DisplaySourceApiTest, DisplaySourceExtension) {
ASSERT_TRUE(RunAppTest("api_test/display_source/api")) << message_;
}
} // namespace extensions
| [
"lixiaodonglove7@aliyun.com"
] | lixiaodonglove7@aliyun.com |
1361f6345f76a84b294670b63581f3d70c5d054f | 1939d1cd5542e1651d2e107971378260d7b423d2 | /CSC_433_Computer_Graphics/mandelbrotSet/mandelbrot.cpp | 706e3ad8c594db513b2b399518830c7f76cc193d | [] | no_license | ellman121/SchoolworkArchive | 367757042e02380c58cb6a655dfc001fed66d8d5 | 3fd183517b3647645a96ad8f062e307fdeba795c | refs/heads/master | 2020-12-29T02:32:43.404393 | 2017-09-07T16:10:43 | 2017-09-07T16:10:43 | 46,295,872 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,462 | cpp | #include <GL/glut.h> // GLUT header includes gl.h and glu.h
#include <GL/freeglut.h>
#include <iostream>
#include <stdlib.h>
#include <vector>
#include <unistd.h>
// Our headers
#include "colorArrays.h"
#include "mandelcuda.h"
#include "view.h"
#include "draw.h"
#include "menus.h"
#include "callbacks.h"
using namespace std;
/* FUNCTION PROTOTYPES */
// Init functions
void glutSetup();
void reset();
/* GLOBAL VARABLES */
// Window stuff
int width, height;
float xMid, yMid, xJul, yJul, scale, interval, range;
bool juliaFlag, infoFlag, colorFlag, mouseFlag, rotateFlag, cudaFlag;
// Utility Variables and Flags
int zoomCount = 0;
int mandelColor = 0, juliaColor = 1;
int ct = 0;
int zoomLimit;
/*
* Function: Main
*
* Authors: Elliott Rarden & Katie Macmillan
*
* Description: Main function will initialize GLUT and then drop into the main loop
*
* Parameters:
* [in] argc - number of command line arguments
* [in] argv - Array of strings for command line args
*
* Returns: [integer] status of the program on exit
*/
int main( int argc, char *argv[] ){
if ((argc > 1) && (argv[1][1] == 's')){
cudaFlag = false;
zoomLimit = 16;
} else {
cudaFlag = true;
zoomLimit = 22;
}
// width and height of the window
width = height = 700;
glutInit(&argc, argv);
glutSetup();
setupMenus();
// go into GL main loop... FOREVER!!!
glutMainLoop();
// "STOP Whining!"
return 0;
}
/*
* Function: glutSetup
*
* Authors: Elliott Rarden & Katie Macmillan
*
* Description: Setup the GLUT parameters, window size, and callbacks
*/
void glutSetup( void ){
reset();
infoFlag = true;
/**base window setup**/
glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE );
glutInitWindowSize( width, height );
glutInitWindowPosition( 200, 0 );
glutCreateWindow( "Fractals Are Beautiful" );
glClearColor( 0.0, 0.0, 0.0, 1.0 );
/**callbacks**/
glutDisplayFunc( displayCallback );
glutReshapeFunc( reshapeCallback );
glutMouseFunc(mouseCallback);
glutKeyboardFunc( keyboardCallback );
glutPassiveMotionFunc(motionCallback);
glutSpecialFunc(specialKeyCallback);
}
/*
* Function: reset
*
* Authors: Elliott Rarden & Katie Macmillan
*
* Description: Sets all points, flags and view dimensions to
* the default settings, bringing the image back
* to the starting position
*/
void reset(){
xMid = 0;
yMid = 0;
xJul = 0;
yJul = 0;
range = 2.0;
scale = 0.5;
interval = 0.00200;
juliaFlag = false;
zoomCount = 0;
}
| [
"ellman121@gmail.com"
] | ellman121@gmail.com |
318b4eb525dce84b4a6841c07eccb17812f49f72 | fe25107d1ba6f559ce401f16136fbfaa3edfdbee | /project/android-studio/mPinLib/src/main/jni/JNIMPinSDKv2.cpp | 6e85b70e8a67b2810bd3249ea3fe8470f3fe8b42 | [
"BSD-3-Clause"
] | permissive | codeaudit/mpin-mobile-sdk | 52656dc809226840f03dc6a1e7348b44f608e099 | f84ae875779d3a123671b9c058f15b4c4f807449 | refs/heads/master | 2021-01-18T02:10:00.434536 | 2015-10-28T15:03:15 | 2015-10-28T15:03:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,736 | cpp | /*******************************************************************************
* Copyright (c) 2012-2015, Certivox All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* For full details regarding our CertiVox terms of service please refer to the following links:
*
* * Our Terms and Conditions - http://www.certivox.com/about-certivox/terms-and-conditions/
*
* * Our Security and Privacy - http://www.certivox.com/about-certivox/security-privacy/
*
* * Our Statement of Position and Our Promise on Software Patents - http://www.certivox.com/about-certivox/patents/
******************************************************************************/
#include "JNIMPinSDKv2.h"
#include "JNICommon.h"
#include "HTTPConnector.h"
#include "Storage.h"
#include "ContextV2.h"
typedef sdkv2::Context Context;
static jlong nConstruct(JNIEnv* env, jobject jobj)
{
return (jlong) new MPinSDKv2();
}
static void nDestruct(JNIEnv* env, jobject jobj, jlong jptr)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
delete sdk;
}
static jobject nInit(JNIEnv* env, jobject jobj, jlong jptr, jobject jconfig, jobject jcontext)
{
MPinSDKv2::StringMap config;
if(jconfig)
{
ReadJavaMap(env, jconfig, config);
}
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->Init(config, Context::Instance(jcontext)));
}
static jobject nTestBackend(JNIEnv* env, jobject jobj, jlong jptr, jstring jserver)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->TestBackend(JavaToStdString(env, jserver)));
}
static jobject nTestBackendRPS(JNIEnv* env, jobject jobj, jlong jptr, jstring jserver, jstring jrpsPrefix)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->TestBackend(JavaToStdString(env, jserver), JavaToStdString(env, jrpsPrefix)));
}
static jobject nSetBackend(JNIEnv* env, jobject jobj, jlong jptr, jstring jserver)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->SetBackend(JavaToStdString(env, jserver)));
}
static jobject nSetBackendRPS(JNIEnv* env, jobject jobj, jlong jptr, jstring jserver, jstring jrpsPrefix)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->SetBackend(JavaToStdString(env, jserver), JavaToStdString(env, jrpsPrefix)));
}
static jobject nMakeNewUser(JNIEnv* env, jobject jobj, jlong jptr, jstring jid, jstring jdeviceName)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
MPinSDKv2::UserPtr user = sdk->MakeNewUser(JavaToStdString(env, jid), JavaToStdString(env, jdeviceName));
jclass clsUser = env->FindClass("com/certivox/models/User");
jmethodID ctorUser = env->GetMethodID(clsUser, "<init>", "(J)V");
return env->NewObject(clsUser, ctorUser, (jlong) new MPinSDKv2::UserPtr(user));
}
static jobject nStartRegistration(JNIEnv* env, jobject jobj, jlong jptr, jobject juser, jstring juserData)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->StartRegistration(JavaToMPinUser(env, juser), JavaToStdString(env, juserData)));
}
static jobject nRestartRegistration(JNIEnv* env, jobject jobj, jlong jptr, jobject juser, jstring juserData)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->RestartRegistration(JavaToMPinUser(env, juser), JavaToStdString(env, juserData)));
}
static jobject nVerifyUser(JNIEnv* env, jobject jobj, jlong jptr, jobject juser, jstring jmpinId, jstring jactivationKey)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->VerifyUser(JavaToMPinUser(env, juser), JavaToStdString(env, jmpinId), JavaToStdString(env, jactivationKey)));
}
static jobject nConfirmRegistration(JNIEnv* env, jobject jobj, jlong jptr, jobject juser, jstring jpushMessageIdentifier)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->ConfirmRegistration(JavaToMPinUser(env, juser), JavaToStdString(env, jpushMessageIdentifier)));
}
static jobject nFinishRegistration(JNIEnv* env, jobject jobj, jlong jptr, jobject juser, jstring jpin)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->FinishRegistration(JavaToMPinUser(env, juser), JavaToStdString(env, jpin)));
}
static jobject nStartAuthentication(JNIEnv* env, jobject jobj, jlong jptr, jobject juser)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->StartAuthentication(JavaToMPinUser(env, juser)));
}
static jobject nCheckAccessNumber(JNIEnv* env, jobject jobj, jlong jptr, jstring jaccessNumber)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->CheckAccessNumber(JavaToStdString(env, jaccessNumber)));
}
static jobject nFinishAuthentication(JNIEnv* env, jobject jobj, jlong jptr, jobject juser, jstring jpin)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->FinishAuthentication(JavaToMPinUser(env, juser), JavaToStdString(env, jpin)));
}
static jobject nFinishAuthenticationResultData(JNIEnv* env, jobject jobj, jlong jptr, jobject juser, jstring jpin, jobject jresultData)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
MPinSDK::String authResultData;
MPinSDK::Status status = sdk->FinishAuthentication(JavaToMPinUser(env, juser), JavaToStdString(env, jpin), authResultData);
jclass clsStringBuilder = env->FindClass("java/lang/StringBuilder");
jmethodID midSetLength = env->GetMethodID(clsStringBuilder, "setLength", "(I)V");
env->CallVoidMethod(jresultData, midSetLength, authResultData.size());
jmethodID midReplace = env->GetMethodID(clsStringBuilder, "replace", "(IILjava/lang/String;)Ljava/lang/StringBuilder;");
env->CallObjectMethod(jresultData, midReplace, 0, authResultData.size(), env->NewStringUTF(authResultData.c_str()));
return MakeJavaStatus(env, status);
}
static jobject nFinishAuthenticationOTP(JNIEnv* env, jobject jobj, jlong jptr, jobject juser, jstring jpin, jobject jotp)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
MPinSDK::OTP otp;
MPinSDK::Status status = sdk->FinishAuthenticationOTP(JavaToMPinUser(env, juser), JavaToStdString(env, jpin), otp);
if(status == MPinSDK::Status::OK)
{
jclass clsOTP = env->FindClass("com/certivox/models/OTP");
jfieldID fidOtp = env->GetFieldID(clsOTP, "otp", "Ljava/lang/String;");
jfieldID fidExpireTime = env->GetFieldID(clsOTP, "expireTime", "J");
jfieldID fidTtlSeconds = env->GetFieldID(clsOTP, "ttlSeconds", "I");
jfieldID fidNowTime = env->GetFieldID(clsOTP, "nowTime", "J");
jfieldID fidStatus = env->GetFieldID(clsOTP, "status", "Lcom/certivox/models/Status;");
env->SetObjectField(jotp, fidOtp, env->NewStringUTF(otp.otp.c_str()));
env->SetLongField(jotp, fidExpireTime, otp.expireTime);
env->SetIntField(jotp, fidTtlSeconds, otp.ttlSeconds);
env->SetLongField(jotp, fidNowTime, otp.nowTime);
env->SetObjectField(jotp, fidStatus, MakeJavaStatus(env, otp.status));
}
return MakeJavaStatus(env, status);
}
static jobject nFinishAuthenticationAN(JNIEnv* env, jobject jobj, jlong jptr, jobject juser, jstring jpin, jstring jaccessNumber)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return MakeJavaStatus(env, sdk->FinishAuthenticationAN(JavaToMPinUser(env, juser), JavaToStdString(env, jpin), JavaToStdString(env, jaccessNumber)));
}
static void nDeleteUser(JNIEnv* env, jobject jobj, jlong jptr, jobject juser)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
sdk->DeleteUser(JavaToMPinUser(env, juser));
}
static void nListUsers(JNIEnv* env, jobject jobj, jlong jptr, jobject jusersList)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
std::vector<MPinSDK::UserPtr> users;
sdk->ListUsers(users);
jclass clsList = env->FindClass("java/util/List");
jmethodID midAdd = env->GetMethodID(clsList, "add", "(Ljava/lang/Object;)Z");
jclass clsUser = env->FindClass("com/certivox/models/User");
jmethodID ctorUser = env->GetMethodID(clsUser, "<init>", "(J)V");
for (std::vector<MPinSDK::UserPtr>::iterator i = users.begin(); i != users.end(); ++i) {
MPinSDK::UserPtr user = *i;
jobject juser = env->NewObject(clsUser, ctorUser, (jlong) new MPinSDK::UserPtr(user));
env->CallBooleanMethod(jusersList, midAdd, juser);
}
}
static jstring nGetVersion(JNIEnv* env, jobject jobj, jlong jptr)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
const char *version = sdk->GetVersion();
return env->NewStringUTF(version);
}
static jboolean nCanLogout(JNIEnv* env, jobject jobj, jlong jptr, jobject juser)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return sdk->CanLogout(JavaToMPinUser(env, juser));
}
static jboolean nLogout(JNIEnv* env, jobject jobj, jlong jptr, jobject juser)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
return sdk->Logout(JavaToMPinUser(env, juser));
}
static jstring nGetClientParam(JNIEnv* env, jobject jobj, jlong jptr, jstring jkey)
{
MPinSDKv2* sdk = (MPinSDKv2*) jptr;
MPinSDK::String result = sdk->GetClientParam(JavaToStdString(env, jkey));
return env->NewStringUTF(result.c_str());
}
static JNINativeMethod g_methodsMPinSDKv2[] =
{
NATIVE_METHOD(nConstruct, "()J"),
NATIVE_METHOD(nDestruct, "(J)V"),
NATIVE_METHOD(nInit, "(JLjava/util/Map;Landroid/content/Context;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nTestBackend, "(JLjava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nTestBackendRPS, "(JLjava/lang/String;Ljava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nSetBackend, "(JLjava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nSetBackendRPS, "(JLjava/lang/String;Ljava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nMakeNewUser, "(JLjava/lang/String;Ljava/lang/String;)Lcom/certivox/models/User;"),
NATIVE_METHOD(nStartRegistration, "(JLcom/certivox/models/User;Ljava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nRestartRegistration, "(JLcom/certivox/models/User;Ljava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nVerifyUser, "(JLcom/certivox/models/User;Ljava/lang/String;Ljava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nConfirmRegistration, "(JLcom/certivox/models/User;Ljava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nFinishRegistration, "(JLcom/certivox/models/User;Ljava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nStartAuthentication, "(JLcom/certivox/models/User;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nCheckAccessNumber, "(JLjava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nFinishAuthentication, "(JLcom/certivox/models/User;Ljava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nFinishAuthenticationResultData, "(JLcom/certivox/models/User;Ljava/lang/String;Ljava/lang/StringBuilder;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nFinishAuthenticationOTP, "(JLcom/certivox/models/User;Ljava/lang/String;Lcom/certivox/models/OTP;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nFinishAuthenticationAN, "(JLcom/certivox/models/User;Ljava/lang/String;Ljava/lang/String;)Lcom/certivox/models/Status;"),
NATIVE_METHOD(nDeleteUser, "(JLcom/certivox/models/User;)V"),
NATIVE_METHOD(nListUsers, "(JLjava/util/List;)V"),
NATIVE_METHOD(nGetVersion, "(J)Ljava/lang/String;"),
NATIVE_METHOD(nCanLogout, "(JLcom/certivox/models/User;)Z"),
NATIVE_METHOD(nLogout, "(JLcom/certivox/models/User;)Z"),
NATIVE_METHOD(nGetClientParam, "(JLjava/lang/String;)Ljava/lang/String;")
};
void RegisterMPinSDKv2JNI(JNIEnv* env)
{
RegisterNativeMethods(env, "com/certivox/mpinsdk/MPinSDKv2", g_methodsMPinSDKv2, ARR_LEN(g_methodsMPinSDKv2));
}
| [
"vassil.angelov@certivox.com"
] | vassil.angelov@certivox.com |
0e472515d42cb00b6e20630cd5ab1dd746e04ba2 | 012784e8de35581e1929306503439bb355be4c4f | /problems/226/p2.cc | 0b81fe224d59eda20fe4b0ce2ef2dea49ec26612 | [] | no_license | silenke/my-leetcode | 7502057c9394e41ddeb2e7fd6c1b8261661639e0 | d24ef0970785c547709b1d3c7228e7d8b98b1f06 | refs/heads/master | 2023-06-05T02:05:48.674311 | 2021-07-01T16:18:29 | 2021-07-01T16:18:29 | 331,948,127 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 633 | cc | #include "..\..\leetcode.h"
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
queue<TreeNode*> q;
if (root) q.emplace(root);
while (!q.empty()) {
TreeNode* node = q.front();
q.pop();
swap(node->left, node->right);
if (node->left) q.emplace(node->left);
if (node->right) q.emplace(node->right);
}
return root;
}
}; | [
"2595756713@qq.com"
] | 2595756713@qq.com |
a199937cb53f35d07c9e3acbf6be03fd2a39fd91 | 211f4b62e185944f68cc2a99a9873811315af193 | /800/271A_Beautiful_Year.cpp | 2c812447c45b00015e476a827e595f9d7316a086 | [] | no_license | manthanghasadiya/CodeForces_Solutions | 6879a56df73c09da035f6565b6514df70ffac6b4 | 16d86dae77add50e294292c88057a5725d71ad88 | refs/heads/main | 2022-12-29T21:05:21.984336 | 2020-10-17T04:58:24 | 2020-10-17T04:58:24 | 304,799,439 | 1 | 0 | null | 2020-10-17T04:50:11 | 2020-10-17T04:50:11 | null | UTF-8 | C++ | false | false | 529 | cpp | //code by Nikhil Nagrale
//nikhilnagrale2 on EveryPlatform
#include <bits/stdc++.h>
using namespace std;
bool areDistinct(int n)
{
map<int, int> dis;
int digit;
while (n)
{
digit = n % 10;
if (dis[digit])
{
return false;
}
dis[digit] = 1;
n /= 10;
}
return true;
}
int main()
{
int n;
cin >> n;
while (++n)
{
if (areDistinct(n))
{
cout << n << endl;
break;
}
}
return 0;
} | [
"nknagrale634@gmail.com"
] | nknagrale634@gmail.com |
3b952086e510d837761feec3bde39ce5545ef27d | 16adaddc92d24bddb0620bfd27bf0044eff5b91a | /multi-render-target/MRT.cpp | 844869dc159aadb947d30d8d52bafa26757eee3e | [] | no_license | terryfeverpitch/GLSL | ae620cdf93ef6e67575739e4435d8342d0bc3a00 | a41131123f7068a3fc10874bc5a99ec7b79bd3fe | refs/heads/master | 2016-09-10T19:41:30.395137 | 2014-07-17T17:35:07 | 2014-07-17T17:35:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,900 | cpp | #include <gl/glew.h>
#include "gl/gluit.h"
#include "gl/glpng.h"
//#include "helper.h"
#pragma comment (lib, "glew32.lib")
#include <stdio.h>
extern GLuint fbo, depthBuffer, img, img2;
extern void initfbo();
int width = 256;
int height = 256;
int mainwin, viewer;
void display(){}
void reshape(int w, int h)
{
glViewport (0,0,w,h);
ViewerReshape(viewer);
}
GLuint p_mrt, p_2sides; // glsl programs
double angle;
void content()
{
// First pass, render to two textures
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
glUseProgram(p_mrt);
glClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef (angle, 0,1,0);
glutWireTeapot(1.0);
glPopMatrix();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glUseProgram(0);
glBegin (GL_LINE_LOOP);
glVertex2i (-2,-2); glVertex2i (2,-2); glVertex2i (2,2); glVertex2i (-2,2);
glEnd();
// second pass, render to both side textures
glUseProgram (p_2sides);
glActiveTexture (GL_TEXTURE0);
glBindTexture (GL_TEXTURE_2D, img);
glActiveTexture (GL_TEXTURE1);
glBindTexture (GL_TEXTURE_2D, img2);
glEnable (GL_POLYGON_OFFSET_FILL);
glPolygonOffset (0.2, 0.2);
glBegin (GL_QUADS);
glMultiTexCoord2f (GL_TEXTURE0, 0.0, 0.0); glVertex2i (-2,-2);
glMultiTexCoord2f (GL_TEXTURE0, 1.0, 0.0); glVertex2i ( 2,-2);
glMultiTexCoord2f (GL_TEXTURE0, 1.0, 1.0); glVertex2i ( 2,2);
glMultiTexCoord2f (GL_TEXTURE0, 0.0, 1.0); glVertex2i (-2,2);
glEnd();
glDisable (GL_POLYGON_OFFSET_FILL);
glutSwapBuffers();
}
void init()
{
glewInit();
glEnable (GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.2f, 0.5f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
initfbo();
glClearColor (.4,.4,.4,1.);
////////////////////////////////////
// MRT shader
extern GLuint setShaders(char*,char*);
p_mrt = setShaders ("mrt.vert", "mrt.frag");
////////////////////////////////////
// two-side texture shader
p_2sides = setShaders ("twoside.vert", "twoside.frag");
glUseProgram(p_2sides);
glUniform1i (glGetUniformLocation (p_2sides, "fronttex"), 0);
glUniform1i (glGetUniformLocation (p_2sides, "backtex"), 1);
glUseProgram(0);
}
void timer (int dummy)
{
angle += 2;
glutTimerFunc (10, timer, 0);
ViewerRedisplay (viewer);
}
void main (int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE);
glutInitWindowSize (width,height);
mainwin = glutCreateWindow ("MRT");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
// both 4,4 on my old sony vaio S56TP
int maxbuffers;
glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxbuffers);
printf ("max color attachments: %d\n", maxbuffers);
glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxbuffers);
printf ("max draw buffers: %d\n", maxbuffers);
viewer = ViewerNew (mainwin, 0,0,width,height, content);
init();
glutTimerFunc (10, timer, 0);
glutMainLoop();
}
| [
"terryfeverpitch@gmail.com"
] | terryfeverpitch@gmail.com |
575f3124818898e73da26caecbd2688cfdaae968 | 0a2cf31d6de42749f3966dff0cd049934553375d | /DeepCopy.cpp | f626bbfb7ed156b07049ca46ba5aab8a794e1acd | [] | no_license | yeerajan/Cplusplus | f6715508d303ecae41666dcab1b8889685adb104 | 31a984d847cf4ec06ba9fb3b8af388654d51250c | refs/heads/main | 2023-03-12T07:49:01.173537 | 2021-03-03T17:37:52 | 2021-03-03T17:37:52 | 344,154,978 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 556 | cpp | #include<iostream>
using namespace std;
class Dummy
{
private:
int a,b;
int *p;
public:
Dummy()
{
p=new int;
}
void setData(int x,int y,int z)
{
a=x; b=y; *p=z;
}
void showData()
{
cout<<"a="<<a<<" b="<<b<<" *p="<<*p;
}
Dummy(Dummy &d)
{
a=d.a; b=d.b;
p=new int;
*p=*(d.p);
}
~Dummy()
{
delete p;
}
};
int main()
{
Dummy d1;
d1.setData(3,4,5);
Dummy d2=d1;
d2.showData();
}
| [
"noreply@github.com"
] | noreply@github.com |
88589d2e5617ce2f7ead76493f8f35287606d9cb | 53b87eb8d72d9b0d6e3c886467ae25fe5683e9e1 | /khiar-ware/khiar-ware/Source.cpp | c427c595a67d91c7b3f11bf341ebda91837a838c | [] | no_license | TheSlayerr/KhiarWare | 53bf05d731dbddb2f97defd1c49ff709322bedd7 | 68bc4f5f4b811d250802d5bd615ea60acad6b547 | refs/heads/master | 2023-02-04T22:19:13.716749 | 2020-12-29T11:06:17 | 2020-12-29T11:06:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,866 | cpp | #include <random>
#include <time.h>
#include <atlstr.h>
#include "Logger.h"
#include "SimpleGlow.h"
#include "MemoryManager.h"
#include "TriggerBot.h"
#include "AutoBhop.h"
#include "Radar.h"
const int max_length = 50;
std::string get_random_name() {
std::string name = "";
int name_length = rand() % max_length;
for (int i = 0; i < name_length; i++) {
int tmp = (char)rand() % 26;
tmp = (tmp < 0) ? tmp + 26 : tmp;
name += (char)((rand() % 2 == 0) ? 'a' + tmp : 'A' + tmp);
}
return name;
}
void set_random_name() {
TCHAR c_name[max_length];
std::string sc_name = get_random_name();
_tcscpy_s(c_name, CA2T(sc_name.c_str()));
SetConsoleTitle(c_name);
}
int get_key() {
for (int vkey = 8; vkey < 255; vkey++) {
if (GetAsyncKeyState(vkey)) {
return vkey;
}
}
return -1;
}
int main() {
srand(time(NULL));
set_random_name();
Logger* logger = new Logger();
MemoryManager* mem = new MemoryManager(logger);
mem->read<DWORD>(mem->get_client_base());
SimpleGlow* glow = new SimpleGlow(mem);
TriggerBot* trigger_bot = new TriggerBot(mem);
AutoBhop* auto_bhop = new AutoBhop(mem);
Radar* radar = new Radar(mem);
logger->log(WARN, "Ready!");
logger->log(INFO, "These are toggle keys:");
logger->log(INFO, "\tWallHack: INSERT");
logger->log(INFO, "\tTriggerBot: HOME");
logger->log(INFO, "\tAutoBhop: PAGEUp");
logger->log(INFO, "\tRadarHack: PAGEDOWN");
logger->log(INFO, "\tExit: DELETE");
bool is_running = true;
int refresh_interval;
while (is_running) {
refresh_interval = rand()%10;
refresh_interval = (refresh_interval < 0) ? refresh_interval + 10: refresh_interval;
Sleep(refresh_interval);
glow->refresh();
//Jump while Space key is pressed
auto_bhop->refresh();
//It shoots when ALT key is DOWN
trigger_bot->refresh();
//Refresh RadarHack
radar->refresh();
switch (get_key()) {
// Exit when DEL pressed
case VK_DELETE: {
logger->log(WARN, "DELETE pressed");
is_running = false;
Sleep(150);
break;
}
// Toggle wall-hack with Insert key
case VK_INSERT: {
glow->toggle();
logger->log(WARN, "WallHack status: " + std::to_string(glow->status()));
Sleep(150);
break;
}
//Toggle TriggerBot with Home key
case VK_HOME: {
trigger_bot->toggle();
logger->log(WARN, "Trigger status: " + std::to_string(trigger_bot->status()));
Sleep(150);
break;
}
//Toggle AutoBhop with PageUp key
case VK_PRIOR: {
auto_bhop->toggle();
logger->log(WARN, "Bhop Status: " + std::to_string(auto_bhop->status()));
Sleep(150);
break;
}
//Toggle Radar with PageDown key
case VK_NEXT: {
radar->toggle();
logger->log(WARN, "Radar Status: " + std::to_string(radar->status()));
Sleep(150);
break;
}
default: {
break;
}
}
}
logger->log(INFO, "Go learn how to play, idiot!");
return 0;
}
| [
"alinaderiparizi@yahoo.com"
] | alinaderiparizi@yahoo.com |
13b5811382139993cfef439c3432fed446db7847 | 00556e3da405e31d873c3fb975ee62490fd81362 | /tests/apps/bodytrack/AnnealingFactor.cpp | d543af57957b9c43ef3829ac9275af9ea4bcbb3d | [
"MIT"
] | permissive | mejbah/AutoPerf | c9c0b07ae8c409dad1162d1f2cb7fa2c2c3e05a7 | 7c9b8bbae164102703eab8ef73fce44231e67533 | refs/heads/master | 2021-12-09T13:52:29.236258 | 2021-11-16T15:12:13 | 2021-11-16T15:12:13 | 123,038,505 | 22 | 5 | MIT | 2021-11-16T15:12:14 | 2018-02-26T22:21:00 | C | WINDOWS-1252 | C++ | false | false | 3,683 | cpp | //-------------------------------------------------------------
// ____ _ _
// / ___|____ _ _ ____ ____| |__ | |
// | | / ___| | | | _ \/ ___| _ \| |
// | |___| | | |_| | | | | |___| | | ||_|
// \____|_| \_____|_| |_|\____|_| |_|(_) Media benchmarks
//
// © 2006, Intel Corporation, licensed under Apache 2.0
//
// file : AnnealingFactor.h
// author : Jean-Yves Bouguet - jean-yves.bouguet@intel.com
// description : Estimates the annealing factor needed
// for the annealed particle filter to target
// a desired particle survival rate
// modified :
//--------------------------------------------------------------
#if defined(HAVE_CONFIG_H)
# include "config.h"
#endif
#include "AnnealingFactor.h"
#include <math.h>
// Computes the difference between the particle survival rate alpha and the desired value alpha_desired
float delta_alpha(float beta,std::vector<float> &ets,float alpha_desired)
{
int N = (int) ets.size();
float B=0;
float F=0;
float ei;
double v;
for(int i=0;i<N;i++)
{ v = beta*ets[i];
if(v>LOG_MAX_FLOAT) return (-alpha_desired); // exit the function is the value is too large. Return the limit value
ei = (float)exp(v);
B += ei;
F += (ei*ei);
}
return (((B*B/F)/N) - alpha_desired);
};
// Estimates the optimal beta coefficient to achieve a particle survival rate of alpha_desired
float BetaAnnealingFactor(std::vector<float> &ets,float alpha_desired, float beta_min, float beta_max )
{
int n_iterations = 0;
// conpute the values at the range extremas:
float delta_alpha_min = delta_alpha(beta_min,ets,alpha_desired);
float delta_alpha_max = delta_alpha(beta_max,ets,alpha_desired);
// Make sure that there is a zero crossing within the range. Otherwise, return 1.0 (i.e. equivalent to no scaling)
if (((delta_alpha_min>0)&&(delta_alpha_max>0))||((delta_alpha_min<0)&&(delta_alpha_max<0))) return 1.0f;
float beta = (beta_min + beta_max)/2;
float delta_alpha_beta = delta_alpha(beta,ets,alpha_desired);
while(((delta_alpha_beta<0.0 ? -delta_alpha_beta : delta_alpha_beta)>ALPHA_PRECISION) && (n_iterations < N_ITER_MAX))
{ if(((delta_alpha_min>0)&&(delta_alpha_beta>0)) || ((delta_alpha_min<=0)&&(delta_alpha_beta<0)))
{ beta_min = beta;
delta_alpha_min = delta_alpha_beta;
}
else
{ beta_max = beta;
delta_alpha_max = delta_alpha_beta;
}
beta = (beta_min + beta_max)/2;
delta_alpha_beta = delta_alpha(beta,ets,alpha_desired);
n_iterations++;
}
return beta;
}
/******************** FUNCTIONS FOR DEBUG PURPOSES ***********************/
// Sets the value of the vector ets for debug purposes:
void set_ets(std::vector<float> &ets)
{
//float vals[25] = {
// 4.3128728695f,0.0000000000f,18.9053596273f,13.1425134762f,17.4484091251f,17.2461182394f,16.6566663579f,10.0850678559f,
// 15.7001027141f,14.6932104123f,9.4194667162f,8.7384354437f,10.1139429009f,14.0191494204f,9.4412632449f,17.4711466418f,
// 8.6149993135f,17.4476798776f,18.8192540642f,8.4540423726f,14.1630306404f,17.2265023809f,3.5324361101f,19.1927652329f,
// 12.5504577255f};
float vals[25] = {
0.0431287287f,0.0000000000f,0.1890535963f,0.1314251348f,0.1744840913f,0.1724611824f,0.1665666636f,0.1008506786f,
0.1570010271f,0.1469321041f,0.0941946672f,0.0873843544f,0.1011394290f,0.1401914942f,0.0944126324f,0.1747114664f,
0.0861499931f,0.1744767988f,0.1881925406f,0.0845404237f,0.1416303064f,0.1722650238f,0.0353243611f,0.1919276523f,
0.1255045773f};
ets.resize(25);
for(int i=0;i<25;i++)
ets[i] = vals[i];
}
| [
"alamm1@alamm1-mac01.sc.intel.com"
] | alamm1@alamm1-mac01.sc.intel.com |
16fe13adbf4fd777b79016855f16873e5bdd290d | 4fe2e466f173c3a3e0f2b2066fc19d3178cc2e77 | /keystore/include/keystore/keystore_promises.h | 3d45016ed4c44201975e4da2b9b88f6b0ff8a507 | [
"Apache-2.0"
] | permissive | Descendant-XI/system_security | f498fcf53d2c9276a1c45d6b624052cba93c1bde | 0036339ea0b724f6253eab8016c2f1f6e5587189 | refs/heads/eleven-staging | 2023-03-19T09:03:23.139577 | 2021-03-09T16:44:10 | 2021-03-09T16:44:10 | 334,286,372 | 1 | 5 | NOASSERTION | 2021-03-09T16:44:11 | 2021-01-29T23:27:37 | C++ | UTF-8 | C++ | false | false | 3,003 | h | /*
**
** Copyright 2018, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#ifndef KEYSTORE_INCLUDE_KEYSTORE_KEYSTORE_PROMISES_H_
#define KEYSTORE_INCLUDE_KEYSTORE_KEYSTORE_PROMISES_H_
#include <android/security/keystore/BnKeystoreCertificateChainCallback.h>
#include <android/security/keystore/BnKeystoreExportKeyCallback.h>
#include <android/security/keystore/BnKeystoreKeyCharacteristicsCallback.h>
#include <android/security/keystore/BnKeystoreOperationResultCallback.h>
#include <android/security/keystore/BnKeystoreResponseCallback.h>
#include <future>
namespace keystore {
template <typename BnInterface, typename Result>
class CallbackPromise : public BnInterface, public std::promise<Result> {
public:
::android::binder::Status onFinished(const Result& result) override {
this->set_value(result);
return ::android::binder::Status::ok();
}
};
template <typename BnInterface, typename... Results>
class CallbackPromise<BnInterface, std::tuple<Results...>>
: public BnInterface, public std::promise<std::tuple<Results...>> {
public:
::android::binder::Status onFinished(const Results&... results) override {
this->set_value({results...});
return ::android::binder::Status::ok();
}
};
using OperationResultPromise =
CallbackPromise<::android::security::keystore::BnKeystoreOperationResultCallback,
::android::security::keymaster::OperationResult>;
using KeystoreResponsePromise =
CallbackPromise<::android::security::keystore::BnKeystoreResponseCallback,
::android::security::keystore::KeystoreResponse>;
using KeyCharacteristicsPromise =
CallbackPromise<::android::security::keystore::BnKeystoreKeyCharacteristicsCallback,
std::tuple<::android::security::keystore::KeystoreResponse,
::android::security::keymaster::KeyCharacteristics>>;
using KeystoreExportPromise =
CallbackPromise<::android::security::keystore::BnKeystoreExportKeyCallback,
::android::security::keymaster::ExportResult>;
using KeyCertChainPromise =
CallbackPromise<::android::security::keystore::BnKeystoreCertificateChainCallback,
std::tuple<::android::security::keystore::KeystoreResponse,
::android::security::keymaster::KeymasterCertificateChain>>;
} // namespace keystore
#endif // KEYSTORE_INCLUDE_KEYSTORE_KEYSTORE_PROMISES_H_
| [
"jdanis@google.com"
] | jdanis@google.com |
36cecdc870a4cef8d945ba580ae2dcfe9001c3fb | d51e54dccbb594a056005cb50a9dbad472ddb034 | /Volume_14/Number_4/Heinly2009/Common/FileIO/BVH.cc | 17e3c457e004690aec33caa8ca4466911fb66d74 | [
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0",
"MIT"
] | permissive | skn123/jgt-code | 4aa8d39d6354a1ede9b141e5e7131e403465f4f7 | 1c80455c8aafe61955f61372380d983ce7453e6d | refs/heads/master | 2023-08-30T22:54:09.412136 | 2023-08-28T20:54:09 | 2023-08-28T20:54:09 | 217,573,703 | 0 | 0 | MIT | 2023-08-29T02:29:29 | 2019-10-25T16:27:56 | MATLAB | UTF-8 | C++ | false | false | 9,317 | cc |
/*
* Copyright 2009, 2010 Grove City College
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <cfloat>
#include <climits>
#include <algorithm>
using std::sort;
#include <iostream>
using std::endl;
using std::ostream;
#include <Common/FileIO/BVH.h>
#include <Common/Utility/OutputCC.h>
namespace FileIO
{
const float BVH::isecCost = 10.f;
const float BVH::travCost = 10.f;
const uint BVH::defaultThreshold = 8;
BVH::BVH(const vector<Object*>& objectsIn, uint threshold_) :
root(0),
threshold(threshold_),
numNodes(0),
numLeaves(0),
leafMin(UINT_MAX),
leafMax(0),
maxDepth(0),
totalCost(0),
objects(objectsIn)
{
build(objects);
}
BVH::~BVH()
{
if (root)
delete root;
}
BVH::Node::Node() :
left(0), right(0)
{
// no-op
}
BVH::Node::~Node()
{
if (objIDs.size() == 0)
{
delete left;
delete right;
}
}
// NOTE(jsh) - passing by value so that as we split and build, we don't
// lose the original data
void BVH::build(vector<Object*> objectsIn)
{
root = new Node();
build(root, objectsIn, 0);
updateBounds(root);
computeCost(totalCost, root, root->box.computeSA());
}
void BVH::build(Node* node, vector<Object*>& objectsIn, uint depth)
{
const uint size = objectsIn.size();
int bestAxis = -1;
uint split = partitionSAH(bestAxis, objectsIn);
if (bestAxis == -1)
{
// Make a leaf node
for (uint i = 0; i < size; ++i)
{
node->objIDs.push_back(objectsIn[i]->objID);
node->box.extend(objectsIn[i]->box);
}
objectsIn.clear();
objectsIn.reserve(0);
node->axis = 0;
++numNodes;
++numLeaves;
leafMin = Min(leafMin, uint(node->objIDs.size()));
leafMax = Max(leafMax, uint(node->objIDs.size()));
sort(node->objIDs.begin(), node->objIDs.end());
}
else
{
// Make an interior node
node->axis = bestAxis;
++numNodes;
node->left = new Node();
node->right = new Node();
vector<Object*> leftObjects;
vector<Object*> rightObjects;
leftObjects.reserve(split);
for (uint i = 0; i < split; ++i)
{
leftObjects.push_back(objectsIn[i]);
}
rightObjects.reserve(size - split);
for (uint i = split; i < size; ++i)
{
rightObjects.push_back(objectsIn[i]);
}
objectsIn.clear();
objectsIn.reserve(0);
// Recursively build hierarchy
++depth;
build(node->left, leftObjects, depth);
build(node->right, rightObjects, depth);
}
maxDepth = Max(maxDepth, depth);
}
uint BVH::partitionSAH(int& bestAxis, vector<Object*>& objectsIn)
{
const uint size = objectsIn.size();
if (size <= threshold)
{
bestAxis = -1;
return -1;
}
CostEval bestCost;
bestCost.cost = isecCost * size;
bestCost.axis = -1;
bestCost.event = -1;
for (uint axis = 0; axis < 3; ++axis)
{
CostEval newCost = {};
if (buildEvents(newCost, objectsIn, axis))
{
if (newCost.cost < bestCost.cost)
{
bestCost = newCost;
}
}
}
bestAxis = bestCost.axis;
if (bestAxis != -1)
{
vector<Event> events;
for (uint i = 0; i < size; ++i)
{
Event newEvent;
newEvent.pos = (objectsIn[i]->box.center())[bestAxis];
newEvent.object = objectsIn[i];
events.push_back(newEvent);
}
sort(events.begin(), events.end(), CompareEvents());
for (uint i = 0; i < size; ++i)
{
objectsIn[i] = events[i].object;
}
uint result = bestCost.event;
if (result == 0 || result == size)
{
return size / 2;
}
return result;
}
return -1;
}
bool BVH::buildEvents(CostEval& newCost,
const vector<Object*>& objectsIn,
uint axis)
{
const uint size = objectsIn.size();
BBox global;
vector<Event> events;
for (uint i = 0; i < size; ++i)
{
Event newEvent;
BBox box = objectsIn[i]->box;
newEvent.pos = (box.center())[axis];
newEvent.object = objectsIn[i];
events.push_back(newEvent);
global.extend(box);
}
sort(events.begin(), events.end(), CompareEvents());
BBox left;
const int numEvents = events.size();
int numLeft = 0;
int numRight = numEvents;
for (int i = 0; i < numEvents; ++i)
{
events[i].numLeft = numLeft;
events[i].numRight = numRight;
events[i].leftArea = left.computeSA();
left.extend(events[i].object->box);
++numLeft;
--numRight;
}
BBox right;
newCost.cost = FLT_MAX;
newCost.event = -1;
for (int i = numEvents - 1; i >= 0; --i)
{
right.extend(events[i].object->box);
if (events[i].numLeft > 0 && events[i].numRight > 0)
{
events[i].rightArea = right.computeSA();
float currentCost = (events[i].numLeft * events[i].leftArea +
events[i].numRight * events[i].rightArea);
currentCost /= global.computeSA();
currentCost *= isecCost;
currentCost += travCost;
events[i].cost = currentCost;
if (currentCost < newCost.cost)
{
newCost.cost = currentCost;
newCost.pos = events[i].pos;
newCost.axis = axis;
newCost.event = i;
newCost.numLeft = events[i].numLeft;
newCost.numRight = events[i].numRight;
}
}
}
return (newCost.event != -1);
}
void BVH::updateBounds(Node* node)
{
node->box.reset();
if (node->objIDs.empty())
{
// Interior node, recurse on children
updateBounds(node->left);
updateBounds(node->right);
node->box.extend(node->left->box);
node->box.extend(node->right->box);
}
else
{
// Leaf node, bound triangles
for (uint i = 0; i < node->objIDs.size(); ++i)
{
node->box.extend(objects[node->objIDs[i]]->box);
}
}
}
void BVH::computeCost(float& totalCost, Node* node, float globalArea) const
{
// Compute cost of BVH according to SAH:
//
// C = travCost*sum[n in nodes] SA_n/SA_scene +
// isecCost*sum[l in leaves] nprims_l(SA_l/SA_scene)
const BBox& bbox = node->box;
// Add traversal cost
totalCost += bbox.computeSA() / globalArea;
if (node->objIDs.size() == 0)
{
// Interior node, recurse on children
computeCost(totalCost, node->left, globalArea);
computeCost(totalCost, node->right, globalArea);
}
else
{
// Leaf node, add intersection cost
totalCost += node->objIDs.size() * bbox.computeSA() / globalArea;
}
}
void BVH::printStats(bool all) const
{
Output("BVH:" << endl);
Output(" scene bounds = " << root->box << endl);
Output(endl);
Output(" leaf threshold = " << threshold << endl);
Output(" leaf range = [" << leafMin << ", " << leafMax << ']'
<< endl);
Output(" maximum depth = " << maxDepth << endl);
Output(" sah cost = " << totalCost << endl);
Output(endl);
Output(" # interior nodes = " << numNodes - numLeaves << endl);
Output(" # leaf nodes = " << numLeaves << endl);
Output(" total # nodes = " << numNodes << endl);
Output(endl);
if (all)
{
Output(" root node = " << root->box << endl);
Output(" lchild = " << root->left << endl);
Output(" rchild = " << root->right << endl);
Output(" ntris = " << root->objIDs.size() << endl);
printNode(root->left);
printNode(root->right);
Output(endl);
}
}
void BVH::printNode(const Node* node) const
{
const uint size = node->objIDs.size();
if (size == 0)
{
Output(" interior node[" << node << "] = "
<< node->box << endl);
Output(" lchild = " << node->left << endl);
Output(" rchild = " << node->right << endl);
Output(" ntris = " << size << endl);
printNode(node->left);
printNode(node->right);
}
else
{
Output(" leaf node[" << node <<"] = "
<< node->box << endl);
Output(" ntris = " << size << endl);
Output(" ");
for (uint i = 0; i < size; ++i)
{
Output(" " << node->objIDs[i]);
}
}
}
ostream& operator<<(ostream& out, const BVH::Node& n)
{
out << n.box << ' ' << n.objIDs.size();
return out;
}
} // namespace FileIO
| [
"erich@acm.org"
] | erich@acm.org |
82beb343695a4b1444c74691499d9d62187f9463 | 5c5c9b30d5a61cd269c783cb9f37e6c093705165 | /hackerrank-solved/hackerrank-cpp/Multi_level_inheritance_hackerrank.cpp | 3486378319212a2985fdc12ce4feb22978f78dee | [] | no_license | logicals7/problem-solving | e74f994eb43b2de7fdf23a120115f3f10700328c | 0756349aab7688227fd6410556d52c07078df511 | refs/heads/main | 2023-03-09T14:56:04.768683 | 2021-02-26T16:22:59 | 2021-02-26T16:22:59 | 315,563,501 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 643 | cpp | #include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
class Triangle{
public:
void triangle(){
cout<<"I am a triangle\n";
}
};
class Isosceles : public Triangle{
public:
void isosceles(){
cout<<"I am an isosceles triangle\n";
}
};
class Equilateral : public Isosceles{
public:
void equilateral(){
cout<<"I am an equilateral triangle\n";
}
};
//Write your code here.
int main(){
Equilateral eqr;
eqr.equilateral();
eqr.isosceles();
eqr.triangle();
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
adc1110216920276437acab1335db19b74bbc55c | 3b9b4049a8e7d38b49e07bb752780b2f1d792851 | /src/third_party/skia/src/gpu/GrClipMaskManager.cpp | e5f13309864ebf05862c6c46099e7bee6f054bde | [
"BSD-3-Clause",
"Apache-2.0",
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-public-domain"
] | permissive | webosce/chromium53 | f8e745e91363586aee9620c609aacf15b3261540 | 9171447efcf0bb393d41d1dc877c7c13c46d8e38 | refs/heads/webosce | 2020-03-26T23:08:14.416858 | 2018-08-23T08:35:17 | 2018-09-20T14:25:18 | 145,513,343 | 0 | 2 | Apache-2.0 | 2019-08-21T22:44:55 | 2018-08-21T05:52:31 | null | UTF-8 | C++ | false | false | 37,067 | cpp | /*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrClipMaskManager.h"
#include "GrCaps.h"
#include "GrDrawingManager.h"
#include "GrDrawContextPriv.h"
#include "GrGpuResourcePriv.h"
#include "GrPaint.h"
#include "GrPathRenderer.h"
#include "GrRenderTarget.h"
#include "GrRenderTargetPriv.h"
#include "GrResourceProvider.h"
#include "GrStencilAttachment.h"
#include "GrSWMaskHelper.h"
#include "SkRasterClip.h"
#include "SkTLazy.h"
#include "batches/GrRectBatchFactory.h"
#include "effects/GrConvexPolyEffect.h"
#include "effects/GrPorterDuffXferProcessor.h"
#include "effects/GrRRectEffect.h"
#include "effects/GrTextureDomain.h"
typedef SkClipStack::Element Element;
static const int kMaxAnalyticElements = 4;
////////////////////////////////////////////////////////////////////////////////
// set up the draw state to enable the aa clipping mask. Besides setting up the
// stage matrix this also alters the vertex layout
static sk_sp<GrFragmentProcessor> create_fp_for_mask(GrTexture* result,
const SkIRect &devBound) {
SkMatrix mat;
// We use device coords to compute the texture coordinates. We set our matrix to be a
// translation to the devBound, and then a scaling matrix to normalized coords.
mat.setIDiv(result->width(), result->height());
mat.preTranslate(SkIntToScalar(-devBound.fLeft),
SkIntToScalar(-devBound.fTop));
SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
return sk_sp<GrFragmentProcessor>(GrTextureDomainEffect::Make(
result,
mat,
GrTextureDomain::MakeTexelDomain(result, domainTexels),
GrTextureDomain::kDecal_Mode,
GrTextureParams::kNone_FilterMode,
kDevice_GrCoordSet));
}
// Does the path in 'element' require SW rendering? If so, return true (and,
// optionally, set 'prOut' to NULL. If not, return false (and, optionally, set
// 'prOut' to the non-SW path renderer that will do the job).
bool GrClipMaskManager::PathNeedsSWRenderer(GrContext* context,
bool hasUserStencilSettings,
const GrDrawContext* drawContext,
const SkMatrix& viewMatrix,
const Element* element,
GrPathRenderer** prOut,
bool needsStencil) {
if (Element::kRect_Type == element->getType()) {
// rects can always be drawn directly w/o using the software path
// TODO: skip rrects once we're drawing them directly.
if (prOut) {
*prOut = nullptr;
}
return false;
} else {
// We shouldn't get here with an empty clip element.
SkASSERT(Element::kEmpty_Type != element->getType());
// the gpu alpha mask will draw the inverse paths as non-inverse to a temp buffer
SkPath path;
element->asPath(&path);
if (path.isInverseFillType()) {
path.toggleInverseFillType();
}
GrPathRendererChain::DrawType type;
if (needsStencil) {
type = element->isAA()
? GrPathRendererChain::kStencilAndColorAntiAlias_DrawType
: GrPathRendererChain::kStencilAndColor_DrawType;
} else {
type = element->isAA()
? GrPathRendererChain::kColorAntiAlias_DrawType
: GrPathRendererChain::kColor_DrawType;
}
GrShape shape(path, GrStyle::SimpleFill());
GrPathRenderer::CanDrawPathArgs canDrawArgs;
canDrawArgs.fShaderCaps = context->caps()->shaderCaps();
canDrawArgs.fViewMatrix = &viewMatrix;
canDrawArgs.fShape = &shape;
canDrawArgs.fAntiAlias = element->isAA();
canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings;
canDrawArgs.fIsStencilBufferMSAA = drawContext->isStencilBufferMultisampled();
// the 'false' parameter disallows use of the SW path renderer
GrPathRenderer* pr = context->drawingManager()->getPathRenderer(canDrawArgs, false, type);
if (prOut) {
*prOut = pr;
}
return SkToBool(!pr);
}
}
/*
* This method traverses the clip stack to see if the GrSoftwarePathRenderer
* will be used on any element. If so, it returns true to indicate that the
* entire clip should be rendered in SW and then uploaded en masse to the gpu.
*/
bool GrClipMaskManager::UseSWOnlyPath(GrContext* context,
const GrPipelineBuilder& pipelineBuilder,
const GrDrawContext* drawContext,
const SkVector& clipToMaskOffset,
const GrReducedClip::ElementList& elements) {
// TODO: generalize this function so that when
// a clip gets complex enough it can just be done in SW regardless
// of whether it would invoke the GrSoftwarePathRenderer.
// Set the matrix so that rendered clip elements are transformed to mask space from clip
// space.
const SkMatrix translate = SkMatrix::MakeTrans(clipToMaskOffset.fX, clipToMaskOffset.fY);
for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
const Element* element = iter.get();
SkRegion::Op op = element->getOp();
bool invert = element->isInverseFilled();
bool needsStencil = invert ||
SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op;
if (PathNeedsSWRenderer(context, pipelineBuilder.hasUserStencilSettings(),
drawContext, translate, element, nullptr, needsStencil)) {
return true;
}
}
return false;
}
static bool get_analytic_clip_processor(const GrReducedClip::ElementList& elements,
bool abortIfAA,
SkVector& clipToRTOffset,
const SkRect* drawBounds,
sk_sp<GrFragmentProcessor>* resultFP) {
SkRect boundsInClipSpace;
if (drawBounds) {
boundsInClipSpace = *drawBounds;
boundsInClipSpace.offset(-clipToRTOffset.fX, -clipToRTOffset.fY);
}
SkASSERT(elements.count() <= kMaxAnalyticElements);
SkSTArray<kMaxAnalyticElements, sk_sp<GrFragmentProcessor>> fps;
GrReducedClip::ElementList::Iter iter(elements);
while (iter.get()) {
SkRegion::Op op = iter.get()->getOp();
bool invert;
bool skip = false;
switch (op) {
case SkRegion::kReplace_Op:
SkASSERT(iter.get() == elements.head());
// Fallthrough, handled same as intersect.
case SkRegion::kIntersect_Op:
invert = false;
if (drawBounds && iter.get()->contains(boundsInClipSpace)) {
skip = true;
}
break;
case SkRegion::kDifference_Op:
invert = true;
// We don't currently have a cheap test for whether a rect is fully outside an
// element's primitive, so don't attempt to set skip.
break;
default:
return false;
}
if (!skip) {
GrPrimitiveEdgeType edgeType;
if (iter.get()->isAA()) {
if (abortIfAA) {
return false;
}
edgeType =
invert ? kInverseFillAA_GrProcessorEdgeType : kFillAA_GrProcessorEdgeType;
} else {
edgeType =
invert ? kInverseFillBW_GrProcessorEdgeType : kFillBW_GrProcessorEdgeType;
}
switch (iter.get()->getType()) {
case SkClipStack::Element::kPath_Type:
fps.emplace_back(GrConvexPolyEffect::Make(edgeType, iter.get()->getPath(),
&clipToRTOffset));
break;
case SkClipStack::Element::kRRect_Type: {
SkRRect rrect = iter.get()->getRRect();
rrect.offset(clipToRTOffset.fX, clipToRTOffset.fY);
fps.emplace_back(GrRRectEffect::Make(edgeType, rrect));
break;
}
case SkClipStack::Element::kRect_Type: {
SkRect rect = iter.get()->getRect();
rect.offset(clipToRTOffset.fX, clipToRTOffset.fY);
fps.emplace_back(GrConvexPolyEffect::Make(edgeType, rect));
break;
}
default:
break;
}
if (!fps.back()) {
return false;
}
}
iter.next();
}
*resultFP = nullptr;
if (fps.count()) {
*resultFP = GrFragmentProcessor::RunInSeries(fps.begin(), fps.count());
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
// sort out what kind of clip mask needs to be created: alpha, stencil,
// scissor, or entirely software
bool GrClipMaskManager::SetupClipping(GrContext* context,
const GrPipelineBuilder& pipelineBuilder,
GrDrawContext* drawContext,
const GrClipStackClip& clip,
const SkRect* devBounds,
GrAppliedClip* out) {
if (!clip.clipStack() || clip.clipStack()->isWideOpen()) {
return true;
}
GrReducedClip::ElementList elements;
int32_t genID = 0;
GrReducedClip::InitialState initialState = GrReducedClip::kAllIn_InitialState;
SkIRect clipSpaceIBounds;
bool requiresAA = false;
SkIRect clipSpaceRTIBounds = SkIRect::MakeWH(drawContext->width(), drawContext->height());
clipSpaceRTIBounds.offset(clip.origin());
SkIRect clipSpaceReduceQueryBounds;
#define DISABLE_DEV_BOUNDS_FOR_CLIP_REDUCTION 0
if (devBounds && !DISABLE_DEV_BOUNDS_FOR_CLIP_REDUCTION) {
SkIRect devIBounds = devBounds->roundOut();
devIBounds.offset(clip.origin());
if (!clipSpaceReduceQueryBounds.intersect(clipSpaceRTIBounds, devIBounds)) {
return false;
}
} else {
clipSpaceReduceQueryBounds = clipSpaceRTIBounds;
}
GrReducedClip::ReduceClipStack(*clip.clipStack(),
clipSpaceReduceQueryBounds,
&elements,
&genID,
&initialState,
&clipSpaceIBounds,
&requiresAA);
if (elements.isEmpty()) {
if (GrReducedClip::kAllIn_InitialState == initialState) {
if (clipSpaceIBounds == clipSpaceRTIBounds) {
return true;
}
} else {
return false;
}
}
// An element count of 4 was chosen because of the common pattern in Blink of:
// isect RR
// diff RR
// isect convex_poly
// isect convex_poly
// when drawing rounded div borders. This could probably be tuned based on a
// configuration's relative costs of switching RTs to generate a mask vs
// longer shaders.
if (elements.count() <= kMaxAnalyticElements) {
SkVector clipToRTOffset = { SkIntToScalar(-clip.origin().fX),
SkIntToScalar(-clip.origin().fY) };
// When there are multiple samples we want to do per-sample clipping, not compute a
// fractional pixel coverage.
bool disallowAnalyticAA = drawContext->isStencilBufferMultisampled();
if (disallowAnalyticAA && !drawContext->numColorSamples()) {
// With a single color sample, any coverage info is lost from color once it hits the
// color buffer anyway, so we may as well use coverage AA if nothing else in the pipe
// is multisampled.
disallowAnalyticAA = pipelineBuilder.isHWAntialias() ||
pipelineBuilder.hasUserStencilSettings();
}
sk_sp<GrFragmentProcessor> clipFP;
if (elements.isEmpty() ||
(requiresAA &&
get_analytic_clip_processor(elements, disallowAnalyticAA, clipToRTOffset, devBounds,
&clipFP))) {
SkIRect scissorSpaceIBounds(clipSpaceIBounds);
scissorSpaceIBounds.offset(-clip.origin());
if (!devBounds || !SkRect::Make(scissorSpaceIBounds).contains(*devBounds)) {
out->makeScissoredFPBased(std::move(clipFP), scissorSpaceIBounds);
return true;
}
out->makeFPBased(std::move(clipFP));
return true;
}
}
// If the stencil buffer is multisampled we can use it to do everything.
if (!drawContext->isStencilBufferMultisampled() && requiresAA) {
sk_sp<GrTexture> result;
// The top-left of the mask corresponds to the top-left corner of the bounds.
SkVector clipToMaskOffset = {
SkIntToScalar(-clipSpaceIBounds.fLeft),
SkIntToScalar(-clipSpaceIBounds.fTop)
};
if (UseSWOnlyPath(context, pipelineBuilder, drawContext,
clipToMaskOffset, elements)) {
// The clip geometry is complex enough that it will be more efficient to create it
// entirely in software
result = CreateSoftwareClipMask(context->textureProvider(),
genID,
initialState,
elements,
clipToMaskOffset,
clipSpaceIBounds);
} else {
result = CreateAlphaClipMask(context,
genID,
initialState,
elements,
clipToMaskOffset,
clipSpaceIBounds);
// If createAlphaClipMask fails it means UseSWOnlyPath has a bug
SkASSERT(result);
}
if (result) {
// The mask's top left coord should be pinned to the rounded-out top left corner of
// clipSpace bounds. We determine the mask's position WRT to the render target here.
SkIRect rtSpaceMaskBounds = clipSpaceIBounds;
rtSpaceMaskBounds.offset(-clip.origin());
out->makeFPBased(create_fp_for_mask(result.get(), rtSpaceMaskBounds));
return true;
}
// if alpha clip mask creation fails fall through to the non-AA code paths
}
// use the stencil clip if we can't represent the clip as a rectangle.
SkIPoint clipSpaceToStencilSpaceOffset = -clip.origin();
CreateStencilClipMask(context,
drawContext,
genID,
initialState,
elements,
clipSpaceIBounds,
clipSpaceToStencilSpaceOffset);
// This must occur after createStencilClipMask. That function may change the scissor. Also, it
// only guarantees that the stencil mask is correct within the bounds it was passed, so we must
// use both stencil and scissor test to the bounds for the final draw.
SkIRect scissorSpaceIBounds(clipSpaceIBounds);
scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
out->makeScissoredStencil(true, scissorSpaceIBounds);
return true;
}
static bool stencil_element(GrDrawContext* dc,
const GrFixedClip& clip,
const GrUserStencilSettings* ss,
const SkMatrix& viewMatrix,
const SkClipStack::Element* element) {
// TODO: Draw rrects directly here.
switch (element->getType()) {
case Element::kEmpty_Type:
SkDEBUGFAIL("Should never get here with an empty element.");
break;
case Element::kRect_Type:
return dc->drawContextPriv().drawAndStencilRect(clip, ss,
element->getOp(),
element->isInverseFilled(),
element->isAA(),
viewMatrix, element->getRect());
break;
default: {
SkPath path;
element->asPath(&path);
if (path.isInverseFillType()) {
path.toggleInverseFillType();
}
return dc->drawContextPriv().drawAndStencilPath(clip, ss,
element->getOp(),
element->isInverseFilled(),
element->isAA(), viewMatrix, path);
break;
}
}
return false;
}
static void draw_element(GrDrawContext* dc,
const GrClip& clip, // TODO: can this just always be WideOpen?
const GrPaint &paint,
const SkMatrix& viewMatrix,
const SkClipStack::Element* element) {
// TODO: Draw rrects directly here.
switch (element->getType()) {
case Element::kEmpty_Type:
SkDEBUGFAIL("Should never get here with an empty element.");
break;
case Element::kRect_Type:
dc->drawRect(clip, paint, viewMatrix, element->getRect());
break;
default: {
SkPath path;
element->asPath(&path);
if (path.isInverseFillType()) {
path.toggleInverseFillType();
}
dc->drawPath(clip, paint, viewMatrix, path, GrStyle::SimpleFill());
break;
}
}
}
////////////////////////////////////////////////////////////////////////////////
// Create a 8-bit clip mask in alpha
static void GetClipMaskKey(int32_t clipGenID, const SkIRect& bounds, GrUniqueKey* key) {
static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
GrUniqueKey::Builder builder(key, kDomain, 3);
builder[0] = clipGenID;
builder[1] = SkToU16(bounds.fLeft) | (SkToU16(bounds.fRight) << 16);
builder[2] = SkToU16(bounds.fTop) | (SkToU16(bounds.fBottom) << 16);
}
sk_sp<GrTexture> GrClipMaskManager::CreateAlphaClipMask(GrContext* context,
int32_t elementsGenID,
GrReducedClip::InitialState initialState,
const GrReducedClip::ElementList& elements,
const SkVector& clipToMaskOffset,
const SkIRect& clipSpaceIBounds) {
GrResourceProvider* resourceProvider = context->resourceProvider();
GrUniqueKey key;
GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
return sk_sp<GrTexture>(texture);
}
// There's no texture in the cache. Let's try to allocate it then.
GrPixelConfig config = kRGBA_8888_GrPixelConfig;
if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
config = kAlpha_8_GrPixelConfig;
}
sk_sp<GrDrawContext> dc(context->newDrawContext(SkBackingFit::kApprox,
clipSpaceIBounds.width(),
clipSpaceIBounds.height(),
config));
if (!dc) {
return nullptr;
}
// The texture may be larger than necessary, this rect represents the part of the texture
// we populate with a rasterization of the clip.
SkIRect maskSpaceIBounds = SkIRect::MakeWH(clipSpaceIBounds.width(), clipSpaceIBounds.height());
// The scratch texture that we are drawing into can be substantially larger than the mask. Only
// clear the part that we care about.
dc->clear(&maskSpaceIBounds,
GrReducedClip::kAllIn_InitialState == initialState ? 0xffffffff : 0x00000000,
true);
// Set the matrix so that rendered clip elements are transformed to mask space from clip
// space.
const SkMatrix translate = SkMatrix::MakeTrans(clipToMaskOffset.fX, clipToMaskOffset.fY);
// It is important that we use maskSpaceIBounds as the stencil rect in the below loop.
// The second pass that zeros the stencil buffer renders the rect maskSpaceIBounds so the first
// pass must not set values outside of this bounds or stencil values outside the rect won't be
// cleared.
// walk through each clip element and perform its set op
for (GrReducedClip::ElementList::Iter iter = elements.headIter(); iter.get(); iter.next()) {
const Element* element = iter.get();
SkRegion::Op op = element->getOp();
bool invert = element->isInverseFilled();
if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
GrFixedClip clip(maskSpaceIBounds);
// draw directly into the result with the stencil set to make the pixels affected
// by the clip shape be non-zero.
static constexpr GrUserStencilSettings kStencilInElement(
GrUserStencilSettings::StaticInit<
0xffff,
GrUserStencilTest::kAlways,
0xffff,
GrUserStencilOp::kReplace,
GrUserStencilOp::kReplace,
0xffff>()
);
if (!stencil_element(dc.get(), clip, &kStencilInElement,
translate, element)) {
return nullptr;
}
// Draw to the exterior pixels (those with a zero stencil value).
static constexpr GrUserStencilSettings kDrawOutsideElement(
GrUserStencilSettings::StaticInit<
0x0000,
GrUserStencilTest::kEqual,
0xffff,
GrUserStencilOp::kZero,
GrUserStencilOp::kZero,
0xffff>()
);
if (!dc->drawContextPriv().drawAndStencilRect(clip, &kDrawOutsideElement,
op, !invert, false,
translate,
SkRect::Make(clipSpaceIBounds))) {
return nullptr;
}
} else {
// all the remaining ops can just be directly draw into the accumulation buffer
GrPaint paint;
paint.setAntiAlias(element->isAA());
paint.setCoverageSetOpXPFactory(op, false);
draw_element(dc.get(), GrNoClip(), paint, translate, element);
}
}
sk_sp<GrTexture> texture(dc->asTexture());
SkASSERT(texture);
texture->resourcePriv().setUniqueKey(key);
return texture;
}
////////////////////////////////////////////////////////////////////////////////
// Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
// (as opposed to canvas) coordinates
bool GrClipMaskManager::CreateStencilClipMask(GrContext* context,
GrDrawContext* drawContext,
int32_t elementsGenID,
GrReducedClip::InitialState initialState,
const GrReducedClip::ElementList& elements,
const SkIRect& clipSpaceIBounds,
const SkIPoint& clipSpaceToStencilOffset) {
SkASSERT(drawContext);
GrStencilAttachment* stencilAttachment = context->resourceProvider()->attachStencilAttachment(
drawContext->accessRenderTarget());
if (nullptr == stencilAttachment) {
return false;
}
// TODO: these need to be swapped over to using a StencilAttachmentProxy
if (stencilAttachment->mustRenderClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset)) {
stencilAttachment->setLastClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset);
// Set the matrix so that rendered clip elements are transformed from clip to stencil space.
SkVector translate = {
SkIntToScalar(clipSpaceToStencilOffset.fX),
SkIntToScalar(clipSpaceToStencilOffset.fY)
};
SkMatrix viewMatrix;
viewMatrix.setTranslate(translate);
// We set the current clip to the bounds so that our recursive draws are scissored to them.
SkIRect stencilSpaceIBounds(clipSpaceIBounds);
stencilSpaceIBounds.offset(clipSpaceToStencilOffset);
GrFixedClip clip(stencilSpaceIBounds);
drawContext->drawContextPriv().clearStencilClip(
stencilSpaceIBounds,
GrReducedClip::kAllIn_InitialState == initialState);
// walk through each clip element and perform its set op
// with the existing clip.
for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
const Element* element = iter.get();
bool useHWAA = element->isAA() && drawContext->isStencilBufferMultisampled();
bool fillInverted = false;
// enabled at bottom of loop
clip.enableStencilClip(false);
// This will be used to determine whether the clip shape can be rendered into the
// stencil with arbitrary stencil settings.
GrPathRenderer::StencilSupport stencilSupport;
SkRegion::Op op = element->getOp();
GrPathRenderer* pr = nullptr;
SkPath clipPath;
if (Element::kRect_Type == element->getType()) {
stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
fillInverted = false;
} else {
element->asPath(&clipPath);
fillInverted = clipPath.isInverseFillType();
if (fillInverted) {
clipPath.toggleInverseFillType();
}
GrShape shape(clipPath, GrStyle::SimpleFill());
GrPathRenderer::CanDrawPathArgs canDrawArgs;
canDrawArgs.fShaderCaps = context->caps()->shaderCaps();
canDrawArgs.fViewMatrix = &viewMatrix;
canDrawArgs.fShape = &shape;
canDrawArgs.fAntiAlias = false;
canDrawArgs.fHasUserStencilSettings = false;
canDrawArgs.fIsStencilBufferMSAA = drawContext->isStencilBufferMultisampled();
pr = context->drawingManager()->getPathRenderer(canDrawArgs, false,
GrPathRendererChain::kStencilOnly_DrawType,
&stencilSupport);
if (!pr) {
return false;
}
}
bool canRenderDirectToStencil =
GrPathRenderer::kNoRestriction_StencilSupport == stencilSupport;
bool drawDirectToClip; // Given the renderer, the element,
// fill rule, and set operation should
// we render the element directly to
// stencil bit used for clipping.
GrUserStencilSettings const* const* stencilPasses =
GrStencilSettings::GetClipPasses(op, canRenderDirectToStencil, fillInverted,
&drawDirectToClip);
// draw the element to the client stencil bits if necessary
if (!drawDirectToClip) {
static constexpr GrUserStencilSettings kDrawToStencil(
GrUserStencilSettings::StaticInit<
0x0000,
GrUserStencilTest::kAlways,
0xffff,
GrUserStencilOp::kIncMaybeClamp,
GrUserStencilOp::kIncMaybeClamp,
0xffff>()
);
if (Element::kRect_Type == element->getType()) {
drawContext->drawContextPriv().stencilRect(clip, &kDrawToStencil, useHWAA,
viewMatrix, element->getRect());
} else {
if (!clipPath.isEmpty()) {
GrShape shape(clipPath, GrStyle::SimpleFill());
if (canRenderDirectToStencil) {
GrPaint paint;
paint.setXPFactory(GrDisableColorXPFactory::Make());
paint.setAntiAlias(element->isAA());
GrPathRenderer::DrawPathArgs args;
args.fResourceProvider = context->resourceProvider();
args.fPaint = &paint;
args.fUserStencilSettings = &kDrawToStencil;
args.fDrawContext = drawContext;
args.fClip = &clip;
args.fColor = GrColor_WHITE;
args.fViewMatrix = &viewMatrix;
args.fShape = &shape;
args.fAntiAlias = false;
args.fGammaCorrect = false;
pr->drawPath(args);
} else {
GrPathRenderer::StencilPathArgs args;
args.fResourceProvider = context->resourceProvider();
args.fDrawContext = drawContext;
args.fClip = &clip;
args.fViewMatrix = &viewMatrix;
args.fIsAA = element->isAA();
args.fShape = &shape;
pr->stencilPath(args);
}
}
}
}
// now we modify the clip bit by rendering either the clip
// element directly or a bounding rect of the entire clip.
clip.enableStencilClip(true);
for (GrUserStencilSettings const* const* pass = stencilPasses; *pass; ++pass) {
if (drawDirectToClip) {
if (Element::kRect_Type == element->getType()) {
drawContext->drawContextPriv().stencilRect(clip, *pass, useHWAA, viewMatrix,
element->getRect());
} else {
GrShape shape(clipPath, GrStyle::SimpleFill());
GrPaint paint;
paint.setXPFactory(GrDisableColorXPFactory::Make());
paint.setAntiAlias(element->isAA());
GrPathRenderer::DrawPathArgs args;
args.fResourceProvider = context->resourceProvider();
args.fPaint = &paint;
args.fUserStencilSettings = *pass;
args.fDrawContext = drawContext;
args.fClip = &clip;
args.fColor = GrColor_WHITE;
args.fViewMatrix = &viewMatrix;
args.fShape = &shape;
args.fAntiAlias = false;
args.fGammaCorrect = false;
pr->drawPath(args);
}
} else {
// The view matrix is setup to do clip space -> stencil space translation, so
// draw rect in clip space.
drawContext->drawContextPriv().stencilRect(clip, *pass, false, viewMatrix,
SkRect::Make(clipSpaceIBounds));
}
}
}
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
sk_sp<GrTexture> GrClipMaskManager::CreateSoftwareClipMask(
GrTextureProvider* texProvider,
int32_t elementsGenID,
GrReducedClip::InitialState initialState,
const GrReducedClip::ElementList& elements,
const SkVector& clipToMaskOffset,
const SkIRect& clipSpaceIBounds) {
GrUniqueKey key;
GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
if (GrTexture* texture = texProvider->findAndRefTextureByUniqueKey(key)) {
return sk_sp<GrTexture>(texture);
}
// The mask texture may be larger than necessary. We round out the clip space bounds and pin
// the top left corner of the resulting rect to the top left of the texture.
SkIRect maskSpaceIBounds = SkIRect::MakeWH(clipSpaceIBounds.width(), clipSpaceIBounds.height());
GrSWMaskHelper helper(texProvider);
// Set the matrix so that rendered clip elements are transformed to mask space from clip
// space.
SkMatrix translate;
translate.setTranslate(clipToMaskOffset);
helper.init(maskSpaceIBounds, &translate);
helper.clear(GrReducedClip::kAllIn_InitialState == initialState ? 0xFF : 0x00);
for (GrReducedClip::ElementList::Iter iter(elements.headIter()) ; iter.get(); iter.next()) {
const Element* element = iter.get();
SkRegion::Op op = element->getOp();
if (SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
// Intersect and reverse difference require modifying pixels outside of the geometry
// that is being "drawn". In both cases we erase all the pixels outside of the geometry
// but leave the pixels inside the geometry alone. For reverse difference we invert all
// the pixels before clearing the ones outside the geometry.
if (SkRegion::kReverseDifference_Op == op) {
SkRect temp = SkRect::Make(clipSpaceIBounds);
// invert the entire scene
helper.drawRect(temp, SkRegion::kXOR_Op, false, 0xFF);
}
SkPath clipPath;
element->asPath(&clipPath);
clipPath.toggleInverseFillType();
GrShape shape(clipPath, GrStyle::SimpleFill());
helper.drawShape(shape, SkRegion::kReplace_Op, element->isAA(), 0x00);
continue;
}
// The other ops (union, xor, diff) only affect pixels inside
// the geometry so they can just be drawn normally
if (Element::kRect_Type == element->getType()) {
helper.drawRect(element->getRect(), op, element->isAA(), 0xFF);
} else {
SkPath path;
element->asPath(&path);
GrShape shape(path, GrStyle::SimpleFill());
helper.drawShape(shape, op, element->isAA(), 0xFF);
}
}
// Allocate clip mask texture
GrSurfaceDesc desc;
desc.fWidth = clipSpaceIBounds.width();
desc.fHeight = clipSpaceIBounds.height();
desc.fConfig = kAlpha_8_GrPixelConfig;
sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
if (!result) {
return nullptr;
}
result->resourcePriv().setUniqueKey(key);
helper.toTexture(result.get());
return result;
}
| [
"changhyeok.bae@lge.com"
] | changhyeok.bae@lge.com |
26fb95320e44496930ba15426b9e93ee05ec260c | 7a138fa71d3e08958d8443992e2d57d504bb593a | /codechef/unclassified/peer/super_friends.cpp | 67174a9bbf726fad9346f9fcbf0a5e5a190f5305 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | sustcoderboy/competitive-programming-archive | 8a254e7542d9f616df73d8aaa9ca23d6242dec9b | 2cd3237f376c609b7c4e87804e36a8cac7ec3402 | refs/heads/master | 2021-01-22T17:38:41.565826 | 2015-11-22T03:50:00 | 2015-11-22T03:50:00 | 46,705,756 | 1 | 0 | null | 2015-11-23T08:10:07 | 2015-11-23T08:10:07 | null | UTF-8 | C++ | false | false | 1,159 | cpp | #include <iostream>
#include <vector>
using namespace std;
constexpr unsigned int modulo {1000000007};
inline
void use_io_optimizations()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
unsigned long long exponentiate(unsigned int base, unsigned int exponent)
{
unsigned long long result {1};
unsigned long long aggregate {base};
for (auto i = exponent; i > 0; i /= 2)
{
if (i % 2 == 1)
{
result = (result * aggregate) % modulo;
}
aggregate = (aggregate * aggregate) % modulo;
}
return result;
}
int main()
{
use_io_optimizations();
unsigned int test_cases;
cin >> test_cases;
for (unsigned int test {0}; test < test_cases; ++test)
{
unsigned int sweets;
cin >> sweets;
if (sweets < 6)
{
cout << "FIGHT\n";
continue;
}
unsigned long long ways {1};
for (unsigned int i {sweets - 5}; i <= sweets - 1; ++i)
{
ways = (ways * i) % modulo;
}
cout << ways * exponentiate(120, modulo - 2) % modulo << '\n';
}
return 0;
}
| [
"gsshopov@gmail.com"
] | gsshopov@gmail.com |
9d18d8d8bd27f04cb23674f7f852ee17f7a8a20a | 6005f7b2f80108f64758e6246e151d1e7467222b | /iOSApp/Classes/Native/Il2CppCompilerCalculateTypeValues_16Table.cpp | e4e7362a6fe3e416a1626dbcc07e4a5654978b92 | [] | no_license | edieYoung/HackRice9 | 88782be9553292f2df50145ab06f4add1c6f03d3 | 6ea225df69581b36884f79ab859f4414b79d9885 | refs/heads/master | 2020-07-29T14:10:39.973562 | 2019-09-22T09:30:39 | 2019-09-22T09:30:39 | 209,834,632 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 176,089 | cpp | #include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include <stdint.h>
#include "il2cpp-class-internals.h"
#include "codegen/il2cpp-codegen.h"
#include "il2cpp-object-internals.h"
// Mono.Security.Interface.IMonoSslStream
struct IMonoSslStream_t3476E6615542EBD74C52117F2B3BE178525AA38F;
// Mono.Security.Interface.MonoTlsProvider
struct MonoTlsProvider_tDCD056C5BBBE59ED6BAF63F25952B406C1143C27;
// System.Byte[]
struct ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821;
// System.Char[]
struct CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2;
// System.Collections.ArrayList
struct ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4;
// System.Collections.Generic.Dictionary`2<System.Int32,System.String>
struct Dictionary_2_t4EFE6A1D6502662B911688316C6920444A18CF0C;
// System.Collections.Generic.IEnumerable`1<System.String>
struct IEnumerable_1_t31EF1520A3A805598500BB6033C14ABDA7116D5E;
// System.Collections.Generic.List`1<System.Security.Cryptography.X509Certificates.X509CertificateImpl>
struct List_1_t37E424CC2C8529EE0DCF9C6ACACB7F4CA9534033;
// System.Collections.IDictionary
struct IDictionary_t1BD5C1546718A374EA8122FBD6C6EE45331E8CE7;
// System.Collections.IEnumerator
struct IEnumerator_t8789118187258CC88B77AFAC6315B5AF87D3E18A;
// System.Diagnostics.StackTrace[]
struct StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196;
// System.IO.Stream
struct Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7;
// System.IO.Stream/ReadWriteTask
struct ReadWriteTask_tFA17EEE8BC5C4C83EAEFCC3662A30DE351ABAA80;
// System.Int32[]
struct Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83;
// System.IntPtr[]
struct IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD;
// System.Net.EndPoint
struct EndPoint_tD87FCEF2780A951E8CE8D808C345FBF2C088D980;
// System.Runtime.Serialization.SafeSerializationManager
struct SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770;
// System.Security.Cryptography.AsnEncodedData
struct AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65;
// System.Security.Cryptography.Oid
struct Oid_tC00A10270EAF16BBF0F2619B9AEC883E0CFE6137;
// System.Security.Cryptography.OidCollection
struct OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E;
// System.Security.Cryptography.X509Certificates.X509Certificate2Collection
struct X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D;
// System.Security.Cryptography.X509Certificates.X509CertificateCollection
struct X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833;
// System.Security.Cryptography.X509Certificates.X509ChainElementCollection
struct X509ChainElementCollection_t7098FB9D22CA34D461370C124E598C629BCADBF4;
// System.Security.Cryptography.X509Certificates.X509ChainImpl
struct X509ChainImpl_t34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67;
// System.Security.Cryptography.X509Certificates.X509ChainPolicy
struct X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD;
// System.Security.Cryptography.X509Certificates.X509ChainStatus[]
struct X509ChainStatusU5BU5D_tA8CCC33D50C4BCF6F657063CD1DACCC3B9A7BFBB;
// System.String
struct String_t;
// System.String[]
struct StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E;
// System.Threading.SemaphoreSlim
struct SemaphoreSlim_t2E2888D1C0C8FAB80823C76F1602E4434B8FA048;
// System.UInt16[]
struct UInt16U5BU5D_t2D4BB1F8C486FF4359FFA7E4A76A8708A684543E;
struct Exception_t_marshaled_com;
struct Exception_t_marshaled_pinvoke;
#ifndef U3CMODULEU3E_T239CA80C3AF3E763FA4B9A9F3CFADF0768B426EE_H
#define U3CMODULEU3E_T239CA80C3AF3E763FA4B9A9F3CFADF0768B426EE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// <Module>
struct U3CModuleU3E_t239CA80C3AF3E763FA4B9A9F3CFADF0768B426EE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CMODULEU3E_T239CA80C3AF3E763FA4B9A9F3CFADF0768B426EE_H
#ifndef U3CMODULEU3E_TDD607E0208590BE5D73D68EB7825AD7A1FBDFCC3_H
#define U3CMODULEU3E_TDD607E0208590BE5D73D68EB7825AD7A1FBDFCC3_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// <Module>
struct U3CModuleU3E_tDD607E0208590BE5D73D68EB7825AD7A1FBDFCC3
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CMODULEU3E_TDD607E0208590BE5D73D68EB7825AD7A1FBDFCC3_H
#ifndef U3CMODULEU3E_T3EC8D1595A762E18CA2FD2325511B3DE2C4947AA_H
#define U3CMODULEU3E_T3EC8D1595A762E18CA2FD2325511B3DE2C4947AA_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// <Module>
struct U3CModuleU3E_t3EC8D1595A762E18CA2FD2325511B3DE2C4947AA
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CMODULEU3E_T3EC8D1595A762E18CA2FD2325511B3DE2C4947AA_H
#ifndef RUNTIMEOBJECT_H
#define RUNTIMEOBJECT_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Object
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEOBJECT_H
#ifndef ASN1_T2B883D12D3493F8395B31D1F0ABD93F43948B27E_H
#define ASN1_T2B883D12D3493F8395B31D1F0ABD93F43948B27E_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Mono.Security.ASN1
struct ASN1_t2B883D12D3493F8395B31D1F0ABD93F43948B27E : public RuntimeObject
{
public:
// System.Byte Mono.Security.ASN1::m_nTag
uint8_t ___m_nTag_0;
// System.Byte[] Mono.Security.ASN1::m_aValue
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___m_aValue_1;
// System.Collections.ArrayList Mono.Security.ASN1::elist
ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 * ___elist_2;
public:
inline static int32_t get_offset_of_m_nTag_0() { return static_cast<int32_t>(offsetof(ASN1_t2B883D12D3493F8395B31D1F0ABD93F43948B27E, ___m_nTag_0)); }
inline uint8_t get_m_nTag_0() const { return ___m_nTag_0; }
inline uint8_t* get_address_of_m_nTag_0() { return &___m_nTag_0; }
inline void set_m_nTag_0(uint8_t value)
{
___m_nTag_0 = value;
}
inline static int32_t get_offset_of_m_aValue_1() { return static_cast<int32_t>(offsetof(ASN1_t2B883D12D3493F8395B31D1F0ABD93F43948B27E, ___m_aValue_1)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_m_aValue_1() const { return ___m_aValue_1; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_m_aValue_1() { return &___m_aValue_1; }
inline void set_m_aValue_1(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___m_aValue_1 = value;
Il2CppCodeGenWriteBarrier((&___m_aValue_1), value);
}
inline static int32_t get_offset_of_elist_2() { return static_cast<int32_t>(offsetof(ASN1_t2B883D12D3493F8395B31D1F0ABD93F43948B27E, ___elist_2)); }
inline ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 * get_elist_2() const { return ___elist_2; }
inline ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 ** get_address_of_elist_2() { return &___elist_2; }
inline void set_elist_2(ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 * value)
{
___elist_2 = value;
Il2CppCodeGenWriteBarrier((&___elist_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASN1_T2B883D12D3493F8395B31D1F0ABD93F43948B27E_H
#ifndef ASN1CONVERT_T5F783CA2300717B94F27A342A75A0E57B73FCC05_H
#define ASN1CONVERT_T5F783CA2300717B94F27A342A75A0E57B73FCC05_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Mono.Security.ASN1Convert
struct ASN1Convert_t5F783CA2300717B94F27A342A75A0E57B73FCC05 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASN1CONVERT_T5F783CA2300717B94F27A342A75A0E57B73FCC05_H
#ifndef BITCONVERTERLE_T4CE9DF1164753ED72B6F4F33581C35FBCAEEC109_H
#define BITCONVERTERLE_T4CE9DF1164753ED72B6F4F33581C35FBCAEEC109_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Mono.Security.BitConverterLE
struct BitConverterLE_t4CE9DF1164753ED72B6F4F33581C35FBCAEEC109 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BITCONVERTERLE_T4CE9DF1164753ED72B6F4F33581C35FBCAEEC109_H
#ifndef CRYPTOCONVERT_TF1F175C2F2C9E65FE7D5FBF0D434B964E4CAFF76_H
#define CRYPTOCONVERT_TF1F175C2F2C9E65FE7D5FBF0D434B964E4CAFF76_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Mono.Security.Cryptography.CryptoConvert
struct CryptoConvert_tF1F175C2F2C9E65FE7D5FBF0D434B964E4CAFF76 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CRYPTOCONVERT_TF1F175C2F2C9E65FE7D5FBF0D434B964E4CAFF76_H
#ifndef MONOTLSPROVIDER_TDCD056C5BBBE59ED6BAF63F25952B406C1143C27_H
#define MONOTLSPROVIDER_TDCD056C5BBBE59ED6BAF63F25952B406C1143C27_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Mono.Security.Interface.MonoTlsProvider
struct MonoTlsProvider_tDCD056C5BBBE59ED6BAF63F25952B406C1143C27 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MONOTLSPROVIDER_TDCD056C5BBBE59ED6BAF63F25952B406C1143C27_H
#ifndef MONOTLSSETTINGS_T5905C7532C92A87F88C8F3440165DF8AA49A1BBF_H
#define MONOTLSSETTINGS_T5905C7532C92A87F88C8F3440165DF8AA49A1BBF_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Mono.Security.Interface.MonoTlsSettings
struct MonoTlsSettings_t5905C7532C92A87F88C8F3440165DF8AA49A1BBF : public RuntimeObject
{
public:
// System.Security.Cryptography.X509Certificates.X509CertificateCollection Mono.Security.Interface.MonoTlsSettings::<TrustAnchors>k__BackingField
X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833 * ___U3CTrustAnchorsU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CTrustAnchorsU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(MonoTlsSettings_t5905C7532C92A87F88C8F3440165DF8AA49A1BBF, ___U3CTrustAnchorsU3Ek__BackingField_0)); }
inline X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833 * get_U3CTrustAnchorsU3Ek__BackingField_0() const { return ___U3CTrustAnchorsU3Ek__BackingField_0; }
inline X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833 ** get_address_of_U3CTrustAnchorsU3Ek__BackingField_0() { return &___U3CTrustAnchorsU3Ek__BackingField_0; }
inline void set_U3CTrustAnchorsU3Ek__BackingField_0(X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833 * value)
{
___U3CTrustAnchorsU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CTrustAnchorsU3Ek__BackingField_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MONOTLSSETTINGS_T5905C7532C92A87F88C8F3440165DF8AA49A1BBF_H
#ifndef ATTRIBUTE_TF048C13FB3C8CFCC53F82290E4A3F621089F9A74_H
#define ATTRIBUTE_TF048C13FB3C8CFCC53F82290E4A3F621089F9A74_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Attribute
struct Attribute_tF048C13FB3C8CFCC53F82290E4A3F621089F9A74 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ATTRIBUTE_TF048C13FB3C8CFCC53F82290E4A3F621089F9A74_H
#ifndef COLLECTIONBASE_TF5D4583FF325726066A9803839A04E9C0084ED01_H
#define COLLECTIONBASE_TF5D4583FF325726066A9803839A04E9C0084ED01_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Collections.CollectionBase
struct CollectionBase_tF5D4583FF325726066A9803839A04E9C0084ED01 : public RuntimeObject
{
public:
// System.Collections.ArrayList System.Collections.CollectionBase::list
ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 * ___list_0;
public:
inline static int32_t get_offset_of_list_0() { return static_cast<int32_t>(offsetof(CollectionBase_tF5D4583FF325726066A9803839A04E9C0084ED01, ___list_0)); }
inline ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 * get_list_0() const { return ___list_0; }
inline ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 ** get_address_of_list_0() { return &___list_0; }
inline void set_list_0(ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 * value)
{
___list_0 = value;
Il2CppCodeGenWriteBarrier((&___list_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COLLECTIONBASE_TF5D4583FF325726066A9803839A04E9C0084ED01_H
#ifndef CONFIGURATIONELEMENT_TF3ECE1CDFD3304CD9D595E758276F014321AD9FE_H
#define CONFIGURATIONELEMENT_TF3ECE1CDFD3304CD9D595E758276F014321AD9FE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Configuration.ConfigurationElement
struct ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONFIGURATIONELEMENT_TF3ECE1CDFD3304CD9D595E758276F014321AD9FE_H
#ifndef CONFIGURATIONSECTIONGROUP_T64AC7C211E1F868ABF1BD604DA43815564D304E6_H
#define CONFIGURATIONSECTIONGROUP_T64AC7C211E1F868ABF1BD604DA43815564D304E6_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Configuration.ConfigurationSectionGroup
struct ConfigurationSectionGroup_t64AC7C211E1F868ABF1BD604DA43815564D304E6 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONFIGURATIONSECTIONGROUP_T64AC7C211E1F868ABF1BD604DA43815564D304E6_H
#ifndef DIAGNOSTICSCONFIGURATIONHANDLER_T885EAAD2DCF9678F16E3BB296E307868ECE68239_H
#define DIAGNOSTICSCONFIGURATIONHANDLER_T885EAAD2DCF9678F16E3BB296E307868ECE68239_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Diagnostics.DiagnosticsConfigurationHandler
struct DiagnosticsConfigurationHandler_t885EAAD2DCF9678F16E3BB296E307868ECE68239 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DIAGNOSTICSCONFIGURATIONHANDLER_T885EAAD2DCF9678F16E3BB296E307868ECE68239_H
#ifndef EXCEPTION_T_H
#define EXCEPTION_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Exception
struct Exception_t : public RuntimeObject
{
public:
// System.String System.Exception::_className
String_t* ____className_1;
// System.String System.Exception::_message
String_t* ____message_2;
// System.Collections.IDictionary System.Exception::_data
RuntimeObject* ____data_3;
// System.Exception System.Exception::_innerException
Exception_t * ____innerException_4;
// System.String System.Exception::_helpURL
String_t* ____helpURL_5;
// System.Object System.Exception::_stackTrace
RuntimeObject * ____stackTrace_6;
// System.String System.Exception::_stackTraceString
String_t* ____stackTraceString_7;
// System.String System.Exception::_remoteStackTraceString
String_t* ____remoteStackTraceString_8;
// System.Int32 System.Exception::_remoteStackIndex
int32_t ____remoteStackIndex_9;
// System.Object System.Exception::_dynamicMethods
RuntimeObject * ____dynamicMethods_10;
// System.Int32 System.Exception::_HResult
int32_t ____HResult_11;
// System.String System.Exception::_source
String_t* ____source_12;
// System.Runtime.Serialization.SafeSerializationManager System.Exception::_safeSerializationManager
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
// System.Diagnostics.StackTrace[] System.Exception::captured_traces
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
// System.IntPtr[] System.Exception::native_trace_ips
IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* ___native_trace_ips_15;
public:
inline static int32_t get_offset_of__className_1() { return static_cast<int32_t>(offsetof(Exception_t, ____className_1)); }
inline String_t* get__className_1() const { return ____className_1; }
inline String_t** get_address_of__className_1() { return &____className_1; }
inline void set__className_1(String_t* value)
{
____className_1 = value;
Il2CppCodeGenWriteBarrier((&____className_1), value);
}
inline static int32_t get_offset_of__message_2() { return static_cast<int32_t>(offsetof(Exception_t, ____message_2)); }
inline String_t* get__message_2() const { return ____message_2; }
inline String_t** get_address_of__message_2() { return &____message_2; }
inline void set__message_2(String_t* value)
{
____message_2 = value;
Il2CppCodeGenWriteBarrier((&____message_2), value);
}
inline static int32_t get_offset_of__data_3() { return static_cast<int32_t>(offsetof(Exception_t, ____data_3)); }
inline RuntimeObject* get__data_3() const { return ____data_3; }
inline RuntimeObject** get_address_of__data_3() { return &____data_3; }
inline void set__data_3(RuntimeObject* value)
{
____data_3 = value;
Il2CppCodeGenWriteBarrier((&____data_3), value);
}
inline static int32_t get_offset_of__innerException_4() { return static_cast<int32_t>(offsetof(Exception_t, ____innerException_4)); }
inline Exception_t * get__innerException_4() const { return ____innerException_4; }
inline Exception_t ** get_address_of__innerException_4() { return &____innerException_4; }
inline void set__innerException_4(Exception_t * value)
{
____innerException_4 = value;
Il2CppCodeGenWriteBarrier((&____innerException_4), value);
}
inline static int32_t get_offset_of__helpURL_5() { return static_cast<int32_t>(offsetof(Exception_t, ____helpURL_5)); }
inline String_t* get__helpURL_5() const { return ____helpURL_5; }
inline String_t** get_address_of__helpURL_5() { return &____helpURL_5; }
inline void set__helpURL_5(String_t* value)
{
____helpURL_5 = value;
Il2CppCodeGenWriteBarrier((&____helpURL_5), value);
}
inline static int32_t get_offset_of__stackTrace_6() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTrace_6)); }
inline RuntimeObject * get__stackTrace_6() const { return ____stackTrace_6; }
inline RuntimeObject ** get_address_of__stackTrace_6() { return &____stackTrace_6; }
inline void set__stackTrace_6(RuntimeObject * value)
{
____stackTrace_6 = value;
Il2CppCodeGenWriteBarrier((&____stackTrace_6), value);
}
inline static int32_t get_offset_of__stackTraceString_7() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTraceString_7)); }
inline String_t* get__stackTraceString_7() const { return ____stackTraceString_7; }
inline String_t** get_address_of__stackTraceString_7() { return &____stackTraceString_7; }
inline void set__stackTraceString_7(String_t* value)
{
____stackTraceString_7 = value;
Il2CppCodeGenWriteBarrier((&____stackTraceString_7), value);
}
inline static int32_t get_offset_of__remoteStackTraceString_8() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackTraceString_8)); }
inline String_t* get__remoteStackTraceString_8() const { return ____remoteStackTraceString_8; }
inline String_t** get_address_of__remoteStackTraceString_8() { return &____remoteStackTraceString_8; }
inline void set__remoteStackTraceString_8(String_t* value)
{
____remoteStackTraceString_8 = value;
Il2CppCodeGenWriteBarrier((&____remoteStackTraceString_8), value);
}
inline static int32_t get_offset_of__remoteStackIndex_9() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackIndex_9)); }
inline int32_t get__remoteStackIndex_9() const { return ____remoteStackIndex_9; }
inline int32_t* get_address_of__remoteStackIndex_9() { return &____remoteStackIndex_9; }
inline void set__remoteStackIndex_9(int32_t value)
{
____remoteStackIndex_9 = value;
}
inline static int32_t get_offset_of__dynamicMethods_10() { return static_cast<int32_t>(offsetof(Exception_t, ____dynamicMethods_10)); }
inline RuntimeObject * get__dynamicMethods_10() const { return ____dynamicMethods_10; }
inline RuntimeObject ** get_address_of__dynamicMethods_10() { return &____dynamicMethods_10; }
inline void set__dynamicMethods_10(RuntimeObject * value)
{
____dynamicMethods_10 = value;
Il2CppCodeGenWriteBarrier((&____dynamicMethods_10), value);
}
inline static int32_t get_offset_of__HResult_11() { return static_cast<int32_t>(offsetof(Exception_t, ____HResult_11)); }
inline int32_t get__HResult_11() const { return ____HResult_11; }
inline int32_t* get_address_of__HResult_11() { return &____HResult_11; }
inline void set__HResult_11(int32_t value)
{
____HResult_11 = value;
}
inline static int32_t get_offset_of__source_12() { return static_cast<int32_t>(offsetof(Exception_t, ____source_12)); }
inline String_t* get__source_12() const { return ____source_12; }
inline String_t** get_address_of__source_12() { return &____source_12; }
inline void set__source_12(String_t* value)
{
____source_12 = value;
Il2CppCodeGenWriteBarrier((&____source_12), value);
}
inline static int32_t get_offset_of__safeSerializationManager_13() { return static_cast<int32_t>(offsetof(Exception_t, ____safeSerializationManager_13)); }
inline SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * get__safeSerializationManager_13() const { return ____safeSerializationManager_13; }
inline SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 ** get_address_of__safeSerializationManager_13() { return &____safeSerializationManager_13; }
inline void set__safeSerializationManager_13(SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * value)
{
____safeSerializationManager_13 = value;
Il2CppCodeGenWriteBarrier((&____safeSerializationManager_13), value);
}
inline static int32_t get_offset_of_captured_traces_14() { return static_cast<int32_t>(offsetof(Exception_t, ___captured_traces_14)); }
inline StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* get_captured_traces_14() const { return ___captured_traces_14; }
inline StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196** get_address_of_captured_traces_14() { return &___captured_traces_14; }
inline void set_captured_traces_14(StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* value)
{
___captured_traces_14 = value;
Il2CppCodeGenWriteBarrier((&___captured_traces_14), value);
}
inline static int32_t get_offset_of_native_trace_ips_15() { return static_cast<int32_t>(offsetof(Exception_t, ___native_trace_ips_15)); }
inline IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* get_native_trace_ips_15() const { return ___native_trace_ips_15; }
inline IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD** get_address_of_native_trace_ips_15() { return &___native_trace_ips_15; }
inline void set_native_trace_ips_15(IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* value)
{
___native_trace_ips_15 = value;
Il2CppCodeGenWriteBarrier((&___native_trace_ips_15), value);
}
};
struct Exception_t_StaticFields
{
public:
// System.Object System.Exception::s_EDILock
RuntimeObject * ___s_EDILock_0;
public:
inline static int32_t get_offset_of_s_EDILock_0() { return static_cast<int32_t>(offsetof(Exception_t_StaticFields, ___s_EDILock_0)); }
inline RuntimeObject * get_s_EDILock_0() const { return ___s_EDILock_0; }
inline RuntimeObject ** get_address_of_s_EDILock_0() { return &___s_EDILock_0; }
inline void set_s_EDILock_0(RuntimeObject * value)
{
___s_EDILock_0 = value;
Il2CppCodeGenWriteBarrier((&___s_EDILock_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Exception
struct Exception_t_marshaled_pinvoke
{
char* ____className_1;
char* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_pinvoke* ____innerException_4;
char* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
char* ____stackTraceString_7;
char* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
char* ____source_12;
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
intptr_t* ___native_trace_ips_15;
};
// Native definition for COM marshalling of System.Exception
struct Exception_t_marshaled_com
{
Il2CppChar* ____className_1;
Il2CppChar* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_com* ____innerException_4;
Il2CppChar* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
Il2CppChar* ____stackTraceString_7;
Il2CppChar* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
Il2CppChar* ____source_12;
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
intptr_t* ___native_trace_ips_15;
};
#endif // EXCEPTION_T_H
#ifndef ENUMERABLE_TECC271C86C6E8F72E4E27C7C8FD5DB7B63D5D737_H
#define ENUMERABLE_TECC271C86C6E8F72E4E27C7C8FD5DB7B63D5D737_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Linq.Enumerable
struct Enumerable_tECC271C86C6E8F72E4E27C7C8FD5DB7B63D5D737 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ENUMERABLE_TECC271C86C6E8F72E4E27C7C8FD5DB7B63D5D737_H
#ifndef ERROR_TDED49FF03F09C0230D8754901206DAAF2D798834_H
#define ERROR_TDED49FF03F09C0230D8754901206DAAF2D798834_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Linq.Error
struct Error_tDED49FF03F09C0230D8754901206DAAF2D798834 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ERROR_TDED49FF03F09C0230D8754901206DAAF2D798834_H
#ifndef MARSHALBYREFOBJECT_TC4577953D0A44D0AB8597CFA868E01C858B1C9AF_H
#define MARSHALBYREFOBJECT_TC4577953D0A44D0AB8597CFA868E01C858B1C9AF_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MarshalByRefObject
struct MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF : public RuntimeObject
{
public:
// System.Object System.MarshalByRefObject::_identity
RuntimeObject * ____identity_0;
public:
inline static int32_t get_offset_of__identity_0() { return static_cast<int32_t>(offsetof(MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF, ____identity_0)); }
inline RuntimeObject * get__identity_0() const { return ____identity_0; }
inline RuntimeObject ** get_address_of__identity_0() { return &____identity_0; }
inline void set__identity_0(RuntimeObject * value)
{
____identity_0 = value;
Il2CppCodeGenWriteBarrier((&____identity_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.MarshalByRefObject
struct MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_pinvoke
{
Il2CppIUnknown* ____identity_0;
};
// Native definition for COM marshalling of System.MarshalByRefObject
struct MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_com
{
Il2CppIUnknown* ____identity_0;
};
#endif // MARSHALBYREFOBJECT_TC4577953D0A44D0AB8597CFA868E01C858B1C9AF_H
#ifndef ENDPOINT_TD87FCEF2780A951E8CE8D808C345FBF2C088D980_H
#define ENDPOINT_TD87FCEF2780A951E8CE8D808C345FBF2C088D980_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.EndPoint
struct EndPoint_tD87FCEF2780A951E8CE8D808C345FBF2C088D980 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ENDPOINT_TD87FCEF2780A951E8CE8D808C345FBF2C088D980_H
#ifndef ASNENCODEDDATA_T7D5EF5337DCAF507CAD7D750552C943F037A9D65_H
#define ASNENCODEDDATA_T7D5EF5337DCAF507CAD7D750552C943F037A9D65_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.AsnEncodedData
struct AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65 : public RuntimeObject
{
public:
// System.Security.Cryptography.Oid System.Security.Cryptography.AsnEncodedData::_oid
Oid_tC00A10270EAF16BBF0F2619B9AEC883E0CFE6137 * ____oid_0;
// System.Byte[] System.Security.Cryptography.AsnEncodedData::_raw
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ____raw_1;
public:
inline static int32_t get_offset_of__oid_0() { return static_cast<int32_t>(offsetof(AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65, ____oid_0)); }
inline Oid_tC00A10270EAF16BBF0F2619B9AEC883E0CFE6137 * get__oid_0() const { return ____oid_0; }
inline Oid_tC00A10270EAF16BBF0F2619B9AEC883E0CFE6137 ** get_address_of__oid_0() { return &____oid_0; }
inline void set__oid_0(Oid_tC00A10270EAF16BBF0F2619B9AEC883E0CFE6137 * value)
{
____oid_0 = value;
Il2CppCodeGenWriteBarrier((&____oid_0), value);
}
inline static int32_t get_offset_of__raw_1() { return static_cast<int32_t>(offsetof(AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65, ____raw_1)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get__raw_1() const { return ____raw_1; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of__raw_1() { return &____raw_1; }
inline void set__raw_1(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
____raw_1 = value;
Il2CppCodeGenWriteBarrier((&____raw_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASNENCODEDDATA_T7D5EF5337DCAF507CAD7D750552C943F037A9D65_H
#ifndef PUBLICKEY_TBA8234EB603A903FCBBBE67D8247393D4CC8D620_H
#define PUBLICKEY_TBA8234EB603A903FCBBBE67D8247393D4CC8D620_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.PublicKey
struct PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620 : public RuntimeObject
{
public:
// System.Security.Cryptography.AsnEncodedData System.Security.Cryptography.X509Certificates.PublicKey::_keyValue
AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65 * ____keyValue_0;
// System.Security.Cryptography.AsnEncodedData System.Security.Cryptography.X509Certificates.PublicKey::_params
AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65 * ____params_1;
// System.Security.Cryptography.Oid System.Security.Cryptography.X509Certificates.PublicKey::_oid
Oid_tC00A10270EAF16BBF0F2619B9AEC883E0CFE6137 * ____oid_2;
public:
inline static int32_t get_offset_of__keyValue_0() { return static_cast<int32_t>(offsetof(PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620, ____keyValue_0)); }
inline AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65 * get__keyValue_0() const { return ____keyValue_0; }
inline AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65 ** get_address_of__keyValue_0() { return &____keyValue_0; }
inline void set__keyValue_0(AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65 * value)
{
____keyValue_0 = value;
Il2CppCodeGenWriteBarrier((&____keyValue_0), value);
}
inline static int32_t get_offset_of__params_1() { return static_cast<int32_t>(offsetof(PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620, ____params_1)); }
inline AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65 * get__params_1() const { return ____params_1; }
inline AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65 ** get_address_of__params_1() { return &____params_1; }
inline void set__params_1(AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65 * value)
{
____params_1 = value;
Il2CppCodeGenWriteBarrier((&____params_1), value);
}
inline static int32_t get_offset_of__oid_2() { return static_cast<int32_t>(offsetof(PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620, ____oid_2)); }
inline Oid_tC00A10270EAF16BBF0F2619B9AEC883E0CFE6137 * get__oid_2() const { return ____oid_2; }
inline Oid_tC00A10270EAF16BBF0F2619B9AEC883E0CFE6137 ** get_address_of__oid_2() { return &____oid_2; }
inline void set__oid_2(Oid_tC00A10270EAF16BBF0F2619B9AEC883E0CFE6137 * value)
{
____oid_2 = value;
Il2CppCodeGenWriteBarrier((&____oid_2), value);
}
};
struct PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620_StaticFields
{
public:
// System.Byte[] System.Security.Cryptography.X509Certificates.PublicKey::Empty
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___Empty_3;
public:
inline static int32_t get_offset_of_Empty_3() { return static_cast<int32_t>(offsetof(PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620_StaticFields, ___Empty_3)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_Empty_3() const { return ___Empty_3; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_Empty_3() { return &___Empty_3; }
inline void set_Empty_3(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___Empty_3 = value;
Il2CppCodeGenWriteBarrier((&___Empty_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PUBLICKEY_TBA8234EB603A903FCBBBE67D8247393D4CC8D620_H
#ifndef X509CERTIFICATEENUMERATOR_T99AEDECD77BFC6083D8C98F9760BF7876D5B886B_H
#define X509CERTIFICATEENUMERATOR_T99AEDECD77BFC6083D8C98F9760BF7876D5B886B_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509CertificateCollection/X509CertificateEnumerator
struct X509CertificateEnumerator_t99AEDECD77BFC6083D8C98F9760BF7876D5B886B : public RuntimeObject
{
public:
// System.Collections.IEnumerator System.Security.Cryptography.X509Certificates.X509CertificateCollection/X509CertificateEnumerator::enumerator
RuntimeObject* ___enumerator_0;
public:
inline static int32_t get_offset_of_enumerator_0() { return static_cast<int32_t>(offsetof(X509CertificateEnumerator_t99AEDECD77BFC6083D8C98F9760BF7876D5B886B, ___enumerator_0)); }
inline RuntimeObject* get_enumerator_0() const { return ___enumerator_0; }
inline RuntimeObject** get_address_of_enumerator_0() { return &___enumerator_0; }
inline void set_enumerator_0(RuntimeObject* value)
{
___enumerator_0 = value;
Il2CppCodeGenWriteBarrier((&___enumerator_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CERTIFICATEENUMERATOR_T99AEDECD77BFC6083D8C98F9760BF7876D5B886B_H
#ifndef X509CERTIFICATEIMPL_T89610BFDE87B872143A4623CFC7F17275EB48313_H
#define X509CERTIFICATEIMPL_T89610BFDE87B872143A4623CFC7F17275EB48313_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509CertificateImpl
struct X509CertificateImpl_t89610BFDE87B872143A4623CFC7F17275EB48313 : public RuntimeObject
{
public:
// System.Byte[] System.Security.Cryptography.X509Certificates.X509CertificateImpl::cachedCertificateHash
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___cachedCertificateHash_0;
public:
inline static int32_t get_offset_of_cachedCertificateHash_0() { return static_cast<int32_t>(offsetof(X509CertificateImpl_t89610BFDE87B872143A4623CFC7F17275EB48313, ___cachedCertificateHash_0)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_cachedCertificateHash_0() const { return ___cachedCertificateHash_0; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_cachedCertificateHash_0() { return &___cachedCertificateHash_0; }
inline void set_cachedCertificateHash_0(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___cachedCertificateHash_0 = value;
Il2CppCodeGenWriteBarrier((&___cachedCertificateHash_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CERTIFICATEIMPL_T89610BFDE87B872143A4623CFC7F17275EB48313_H
#ifndef X509CERTIFICATEIMPLCOLLECTION_T2F7A6E9F160116CE64224D56187C92ECD7FA7242_H
#define X509CERTIFICATEIMPLCOLLECTION_T2F7A6E9F160116CE64224D56187C92ECD7FA7242_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509CertificateImplCollection
struct X509CertificateImplCollection_t2F7A6E9F160116CE64224D56187C92ECD7FA7242 : public RuntimeObject
{
public:
// System.Collections.Generic.List`1<System.Security.Cryptography.X509Certificates.X509CertificateImpl> System.Security.Cryptography.X509Certificates.X509CertificateImplCollection::list
List_1_t37E424CC2C8529EE0DCF9C6ACACB7F4CA9534033 * ___list_0;
public:
inline static int32_t get_offset_of_list_0() { return static_cast<int32_t>(offsetof(X509CertificateImplCollection_t2F7A6E9F160116CE64224D56187C92ECD7FA7242, ___list_0)); }
inline List_1_t37E424CC2C8529EE0DCF9C6ACACB7F4CA9534033 * get_list_0() const { return ___list_0; }
inline List_1_t37E424CC2C8529EE0DCF9C6ACACB7F4CA9534033 ** get_address_of_list_0() { return &___list_0; }
inline void set_list_0(List_1_t37E424CC2C8529EE0DCF9C6ACACB7F4CA9534033 * value)
{
___list_0 = value;
Il2CppCodeGenWriteBarrier((&___list_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CERTIFICATEIMPLCOLLECTION_T2F7A6E9F160116CE64224D56187C92ECD7FA7242_H
#ifndef X509CHAIN_T4A28E9A30CBB331C9B68AE4AFCB30625C6C8B538_H
#define X509CHAIN_T4A28E9A30CBB331C9B68AE4AFCB30625C6C8B538_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509Chain
struct X509Chain_t4A28E9A30CBB331C9B68AE4AFCB30625C6C8B538 : public RuntimeObject
{
public:
// System.Security.Cryptography.X509Certificates.X509ChainImpl System.Security.Cryptography.X509Certificates.X509Chain::impl
X509ChainImpl_t34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67 * ___impl_0;
public:
inline static int32_t get_offset_of_impl_0() { return static_cast<int32_t>(offsetof(X509Chain_t4A28E9A30CBB331C9B68AE4AFCB30625C6C8B538, ___impl_0)); }
inline X509ChainImpl_t34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67 * get_impl_0() const { return ___impl_0; }
inline X509ChainImpl_t34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67 ** get_address_of_impl_0() { return &___impl_0; }
inline void set_impl_0(X509ChainImpl_t34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67 * value)
{
___impl_0 = value;
Il2CppCodeGenWriteBarrier((&___impl_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CHAIN_T4A28E9A30CBB331C9B68AE4AFCB30625C6C8B538_H
#ifndef X509CHAINELEMENTCOLLECTION_T7098FB9D22CA34D461370C124E598C629BCADBF4_H
#define X509CHAINELEMENTCOLLECTION_T7098FB9D22CA34D461370C124E598C629BCADBF4_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509ChainElementCollection
struct X509ChainElementCollection_t7098FB9D22CA34D461370C124E598C629BCADBF4 : public RuntimeObject
{
public:
// System.Collections.ArrayList System.Security.Cryptography.X509Certificates.X509ChainElementCollection::_list
ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 * ____list_0;
public:
inline static int32_t get_offset_of__list_0() { return static_cast<int32_t>(offsetof(X509ChainElementCollection_t7098FB9D22CA34D461370C124E598C629BCADBF4, ____list_0)); }
inline ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 * get__list_0() const { return ____list_0; }
inline ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 ** get_address_of__list_0() { return &____list_0; }
inline void set__list_0(ArrayList_t4131E0C29C7E1B9BC9DFE37BEC41A5EB1481ADF4 * value)
{
____list_0 = value;
Il2CppCodeGenWriteBarrier((&____list_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CHAINELEMENTCOLLECTION_T7098FB9D22CA34D461370C124E598C629BCADBF4_H
#ifndef X509CHAINELEMENTENUMERATOR_TEF7D4F9F87BAAF9A067923B6D4686C2AA4DB5B20_H
#define X509CHAINELEMENTENUMERATOR_TEF7D4F9F87BAAF9A067923B6D4686C2AA4DB5B20_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509ChainElementEnumerator
struct X509ChainElementEnumerator_tEF7D4F9F87BAAF9A067923B6D4686C2AA4DB5B20 : public RuntimeObject
{
public:
// System.Collections.IEnumerator System.Security.Cryptography.X509Certificates.X509ChainElementEnumerator::enumerator
RuntimeObject* ___enumerator_0;
public:
inline static int32_t get_offset_of_enumerator_0() { return static_cast<int32_t>(offsetof(X509ChainElementEnumerator_tEF7D4F9F87BAAF9A067923B6D4686C2AA4DB5B20, ___enumerator_0)); }
inline RuntimeObject* get_enumerator_0() const { return ___enumerator_0; }
inline RuntimeObject** get_address_of_enumerator_0() { return &___enumerator_0; }
inline void set_enumerator_0(RuntimeObject* value)
{
___enumerator_0 = value;
Il2CppCodeGenWriteBarrier((&___enumerator_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CHAINELEMENTENUMERATOR_TEF7D4F9F87BAAF9A067923B6D4686C2AA4DB5B20_H
#ifndef X509CHAINIMPL_T34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67_H
#define X509CHAINIMPL_T34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509ChainImpl
struct X509ChainImpl_t34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CHAINIMPL_T34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67_H
#ifndef X509HELPER2_TD0B65FDE6197798D9719F42AAEA8D9063A8916C7_H
#define X509HELPER2_TD0B65FDE6197798D9719F42AAEA8D9063A8916C7_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509Helper2
struct X509Helper2_tD0B65FDE6197798D9719F42AAEA8D9063A8916C7 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509HELPER2_TD0B65FDE6197798D9719F42AAEA8D9063A8916C7_H
#ifndef X509UTILS_T596E1974703C7988010495E60F15BE9680FC71B8_H
#define X509UTILS_T596E1974703C7988010495E60F15BE9680FC71B8_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509Utils
struct X509Utils_t596E1974703C7988010495E60F15BE9680FC71B8 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509UTILS_T596E1974703C7988010495E60F15BE9680FC71B8_H
#ifndef VALUETYPE_T4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_H
#define VALUETYPE_T4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_com
{
};
#endif // VALUETYPE_T4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_H
#ifndef __STATICARRAYINITTYPESIZEU3D128_T4A42759E6E25B0C61E6036A661F4344DE92C2905_H
#define __STATICARRAYINITTYPESIZEU3D128_T4A42759E6E25B0C61E6036A661F4344DE92C2905_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// <PrivateImplementationDetails>/__StaticArrayInitTypeSize=128
struct __StaticArrayInitTypeSizeU3D128_t4A42759E6E25B0C61E6036A661F4344DE92C2905
{
public:
union
{
struct
{
union
{
};
};
uint8_t __StaticArrayInitTypeSizeU3D128_t4A42759E6E25B0C61E6036A661F4344DE92C2905__padding[128];
};
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // __STATICARRAYINITTYPESIZEU3D128_T4A42759E6E25B0C61E6036A661F4344DE92C2905_H
#ifndef __STATICARRAYINITTYPESIZEU3D32_T5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA_H
#define __STATICARRAYINITTYPESIZEU3D32_T5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// <PrivateImplementationDetails>/__StaticArrayInitTypeSize=32
struct __StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA
{
public:
union
{
struct
{
union
{
};
};
uint8_t __StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA__padding[32];
};
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // __STATICARRAYINITTYPESIZEU3D32_T5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA_H
#ifndef BOOLEAN_TB53F6830F670160873277339AA58F15CAED4399C_H
#define BOOLEAN_TB53F6830F670160873277339AA58F15CAED4399C_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Boolean
struct Boolean_tB53F6830F670160873277339AA58F15CAED4399C
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((&___TrueString_5), value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((&___FalseString_6), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BOOLEAN_TB53F6830F670160873277339AA58F15CAED4399C_H
#ifndef CONFIGURATIONELEMENTCOLLECTION_TB0DA3194B9C1528D2627B291C79B560C68A78FCC_H
#define CONFIGURATIONELEMENTCOLLECTION_TB0DA3194B9C1528D2627B291C79B560C68A78FCC_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Configuration.ConfigurationElementCollection
struct ConfigurationElementCollection_tB0DA3194B9C1528D2627B291C79B560C68A78FCC : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONFIGURATIONELEMENTCOLLECTION_TB0DA3194B9C1528D2627B291C79B560C68A78FCC_H
#ifndef CONFIGURATIONSECTION_T044F68052218C8000611AE9ADD5F66E62A632B34_H
#define CONFIGURATIONSECTION_T044F68052218C8000611AE9ADD5F66E62A632B34_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Configuration.ConfigurationSection
struct ConfigurationSection_t044F68052218C8000611AE9ADD5F66E62A632B34 : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONFIGURATIONSECTION_T044F68052218C8000611AE9ADD5F66E62A632B34_H
#ifndef DATETIME_T349B7449FBAAFF4192636E2B7A07694DA9236132_H
#define DATETIME_T349B7449FBAAFF4192636E2B7A07694DA9236132_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.DateTime
struct DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132
{
public:
// System.UInt64 System.DateTime::dateData
uint64_t ___dateData_44;
public:
inline static int32_t get_offset_of_dateData_44() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132, ___dateData_44)); }
inline uint64_t get_dateData_44() const { return ___dateData_44; }
inline uint64_t* get_address_of_dateData_44() { return &___dateData_44; }
inline void set_dateData_44(uint64_t value)
{
___dateData_44 = value;
}
};
struct DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields
{
public:
// System.Int32[] System.DateTime::DaysToMonth365
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___DaysToMonth365_29;
// System.Int32[] System.DateTime::DaysToMonth366
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___DaysToMonth366_30;
// System.DateTime System.DateTime::MinValue
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 ___MinValue_31;
// System.DateTime System.DateTime::MaxValue
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 ___MaxValue_32;
public:
inline static int32_t get_offset_of_DaysToMonth365_29() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___DaysToMonth365_29)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_DaysToMonth365_29() const { return ___DaysToMonth365_29; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_DaysToMonth365_29() { return &___DaysToMonth365_29; }
inline void set_DaysToMonth365_29(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___DaysToMonth365_29 = value;
Il2CppCodeGenWriteBarrier((&___DaysToMonth365_29), value);
}
inline static int32_t get_offset_of_DaysToMonth366_30() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___DaysToMonth366_30)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_DaysToMonth366_30() const { return ___DaysToMonth366_30; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_DaysToMonth366_30() { return &___DaysToMonth366_30; }
inline void set_DaysToMonth366_30(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___DaysToMonth366_30 = value;
Il2CppCodeGenWriteBarrier((&___DaysToMonth366_30), value);
}
inline static int32_t get_offset_of_MinValue_31() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___MinValue_31)); }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 get_MinValue_31() const { return ___MinValue_31; }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 * get_address_of_MinValue_31() { return &___MinValue_31; }
inline void set_MinValue_31(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 value)
{
___MinValue_31 = value;
}
inline static int32_t get_offset_of_MaxValue_32() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___MaxValue_32)); }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 get_MaxValue_32() const { return ___MaxValue_32; }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 * get_address_of_MaxValue_32() { return &___MaxValue_32; }
inline void set_MaxValue_32(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 value)
{
___MaxValue_32 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DATETIME_T349B7449FBAAFF4192636E2B7A07694DA9236132_H
#ifndef ENUM_T2AF27C02B8653AE29442467390005ABC74D8F521_H
#define ENUM_T2AF27C02B8653AE29442467390005ABC74D8F521_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521 : public ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF
{
public:
public:
};
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((&___enumSeperatorCharArray_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_marshaled_com
{
};
#endif // ENUM_T2AF27C02B8653AE29442467390005ABC74D8F521_H
#ifndef STREAM_TFC50657DD5AAB87770987F9179D934A51D99D5E7_H
#define STREAM_TFC50657DD5AAB87770987F9179D934A51D99D5E7_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.IO.Stream
struct Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7 : public MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF
{
public:
// System.IO.Stream/ReadWriteTask System.IO.Stream::_activeReadWriteTask
ReadWriteTask_tFA17EEE8BC5C4C83EAEFCC3662A30DE351ABAA80 * ____activeReadWriteTask_2;
// System.Threading.SemaphoreSlim System.IO.Stream::_asyncActiveSemaphore
SemaphoreSlim_t2E2888D1C0C8FAB80823C76F1602E4434B8FA048 * ____asyncActiveSemaphore_3;
public:
inline static int32_t get_offset_of__activeReadWriteTask_2() { return static_cast<int32_t>(offsetof(Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7, ____activeReadWriteTask_2)); }
inline ReadWriteTask_tFA17EEE8BC5C4C83EAEFCC3662A30DE351ABAA80 * get__activeReadWriteTask_2() const { return ____activeReadWriteTask_2; }
inline ReadWriteTask_tFA17EEE8BC5C4C83EAEFCC3662A30DE351ABAA80 ** get_address_of__activeReadWriteTask_2() { return &____activeReadWriteTask_2; }
inline void set__activeReadWriteTask_2(ReadWriteTask_tFA17EEE8BC5C4C83EAEFCC3662A30DE351ABAA80 * value)
{
____activeReadWriteTask_2 = value;
Il2CppCodeGenWriteBarrier((&____activeReadWriteTask_2), value);
}
inline static int32_t get_offset_of__asyncActiveSemaphore_3() { return static_cast<int32_t>(offsetof(Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7, ____asyncActiveSemaphore_3)); }
inline SemaphoreSlim_t2E2888D1C0C8FAB80823C76F1602E4434B8FA048 * get__asyncActiveSemaphore_3() const { return ____asyncActiveSemaphore_3; }
inline SemaphoreSlim_t2E2888D1C0C8FAB80823C76F1602E4434B8FA048 ** get_address_of__asyncActiveSemaphore_3() { return &____asyncActiveSemaphore_3; }
inline void set__asyncActiveSemaphore_3(SemaphoreSlim_t2E2888D1C0C8FAB80823C76F1602E4434B8FA048 * value)
{
____asyncActiveSemaphore_3 = value;
Il2CppCodeGenWriteBarrier((&____asyncActiveSemaphore_3), value);
}
};
struct Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7_StaticFields
{
public:
// System.IO.Stream System.IO.Stream::Null
Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7 * ___Null_1;
public:
inline static int32_t get_offset_of_Null_1() { return static_cast<int32_t>(offsetof(Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7_StaticFields, ___Null_1)); }
inline Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7 * get_Null_1() const { return ___Null_1; }
inline Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7 ** get_address_of_Null_1() { return &___Null_1; }
inline void set_Null_1(Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7 * value)
{
___Null_1 = value;
Il2CppCodeGenWriteBarrier((&___Null_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STREAM_TFC50657DD5AAB87770987F9179D934A51D99D5E7_H
#ifndef BYPASSELEMENT_T89C59A549C7A25609AA5C200352CD9E310172BAF_H
#define BYPASSELEMENT_T89C59A549C7A25609AA5C200352CD9E310172BAF_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.BypassElement
struct BypassElement_t89C59A549C7A25609AA5C200352CD9E310172BAF : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BYPASSELEMENT_T89C59A549C7A25609AA5C200352CD9E310172BAF_H
#ifndef CONNECTIONMANAGEMENTELEMENT_TABDA95F63A9CBFC2720D7D3F15C5B352EC5CE7AD_H
#define CONNECTIONMANAGEMENTELEMENT_TABDA95F63A9CBFC2720D7D3F15C5B352EC5CE7AD_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.ConnectionManagementElement
struct ConnectionManagementElement_tABDA95F63A9CBFC2720D7D3F15C5B352EC5CE7AD : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONNECTIONMANAGEMENTELEMENT_TABDA95F63A9CBFC2720D7D3F15C5B352EC5CE7AD_H
#ifndef HTTPWEBREQUESTELEMENT_T3E2FC0EB83C362CC92300949AF90A0B0BE01EA3D_H
#define HTTPWEBREQUESTELEMENT_T3E2FC0EB83C362CC92300949AF90A0B0BE01EA3D_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.HttpWebRequestElement
struct HttpWebRequestElement_t3E2FC0EB83C362CC92300949AF90A0B0BE01EA3D : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HTTPWEBREQUESTELEMENT_T3E2FC0EB83C362CC92300949AF90A0B0BE01EA3D_H
#ifndef IPV6ELEMENT_TCA869DC79FE3740DBDECC47877F1676294DB4A23_H
#define IPV6ELEMENT_TCA869DC79FE3740DBDECC47877F1676294DB4A23_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.Ipv6Element
struct Ipv6Element_tCA869DC79FE3740DBDECC47877F1676294DB4A23 : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // IPV6ELEMENT_TCA869DC79FE3740DBDECC47877F1676294DB4A23_H
#ifndef NETSECTIONGROUP_TA4ACD82AFE8B5C11E509FA8623D554BB5B4DB591_H
#define NETSECTIONGROUP_TA4ACD82AFE8B5C11E509FA8623D554BB5B4DB591_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.NetSectionGroup
struct NetSectionGroup_tA4ACD82AFE8B5C11E509FA8623D554BB5B4DB591 : public ConfigurationSectionGroup_t64AC7C211E1F868ABF1BD604DA43815564D304E6
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // NETSECTIONGROUP_TA4ACD82AFE8B5C11E509FA8623D554BB5B4DB591_H
#ifndef PERFORMANCECOUNTERSELEMENT_TCE4CFF0A3503E44D7B8EC6E85FD3C50EB1A1B570_H
#define PERFORMANCECOUNTERSELEMENT_TCE4CFF0A3503E44D7B8EC6E85FD3C50EB1A1B570_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.PerformanceCountersElement
struct PerformanceCountersElement_tCE4CFF0A3503E44D7B8EC6E85FD3C50EB1A1B570 : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PERFORMANCECOUNTERSELEMENT_TCE4CFF0A3503E44D7B8EC6E85FD3C50EB1A1B570_H
#ifndef PROXYELEMENT_TBD5D75620576BA5BB5521C11D09E0A6E996F9449_H
#define PROXYELEMENT_TBD5D75620576BA5BB5521C11D09E0A6E996F9449_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.ProxyElement
struct ProxyElement_tBD5D75620576BA5BB5521C11D09E0A6E996F9449 : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PROXYELEMENT_TBD5D75620576BA5BB5521C11D09E0A6E996F9449_H
#ifndef SERVICEPOINTMANAGERELEMENT_TD8D1491569C963460C14DF4D42ED05DF34428CFC_H
#define SERVICEPOINTMANAGERELEMENT_TD8D1491569C963460C14DF4D42ED05DF34428CFC_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.ServicePointManagerElement
struct ServicePointManagerElement_tD8D1491569C963460C14DF4D42ED05DF34428CFC : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SERVICEPOINTMANAGERELEMENT_TD8D1491569C963460C14DF4D42ED05DF34428CFC_H
#ifndef SOCKETELEMENT_T32F016077CBED287B80063811E80BCCC7E8B1BF9_H
#define SOCKETELEMENT_T32F016077CBED287B80063811E80BCCC7E8B1BF9_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.SocketElement
struct SocketElement_t32F016077CBED287B80063811E80BCCC7E8B1BF9 : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SOCKETELEMENT_T32F016077CBED287B80063811E80BCCC7E8B1BF9_H
#ifndef WEBPROXYSCRIPTELEMENT_T4302A26A6D4E02146662B30E3452A5167966E6B3_H
#define WEBPROXYSCRIPTELEMENT_T4302A26A6D4E02146662B30E3452A5167966E6B3_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.WebProxyScriptElement
struct WebProxyScriptElement_t4302A26A6D4E02146662B30E3452A5167966E6B3 : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WEBPROXYSCRIPTELEMENT_T4302A26A6D4E02146662B30E3452A5167966E6B3_H
#ifndef WEBREQUESTMODULEELEMENT_TE81A1FA5B9B4BCFB1ED015287A2D4F9EED37F3EC_H
#define WEBREQUESTMODULEELEMENT_TE81A1FA5B9B4BCFB1ED015287A2D4F9EED37F3EC_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.WebRequestModuleElement
struct WebRequestModuleElement_tE81A1FA5B9B4BCFB1ED015287A2D4F9EED37F3EC : public ConfigurationElement_tF3ECE1CDFD3304CD9D595E758276F014321AD9FE
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WEBREQUESTMODULEELEMENT_TE81A1FA5B9B4BCFB1ED015287A2D4F9EED37F3EC_H
#ifndef IPV6ADDRESSFORMATTER_T451290B1C6FD64B6C59F95D99EDB4A9CC703BA90_H
#define IPV6ADDRESSFORMATTER_T451290B1C6FD64B6C59F95D99EDB4A9CC703BA90_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.IPv6AddressFormatter
struct IPv6AddressFormatter_t451290B1C6FD64B6C59F95D99EDB4A9CC703BA90
{
public:
// System.UInt16[] System.Net.IPv6AddressFormatter::address
UInt16U5BU5D_t2D4BB1F8C486FF4359FFA7E4A76A8708A684543E* ___address_0;
// System.Int64 System.Net.IPv6AddressFormatter::scopeId
int64_t ___scopeId_1;
public:
inline static int32_t get_offset_of_address_0() { return static_cast<int32_t>(offsetof(IPv6AddressFormatter_t451290B1C6FD64B6C59F95D99EDB4A9CC703BA90, ___address_0)); }
inline UInt16U5BU5D_t2D4BB1F8C486FF4359FFA7E4A76A8708A684543E* get_address_0() const { return ___address_0; }
inline UInt16U5BU5D_t2D4BB1F8C486FF4359FFA7E4A76A8708A684543E** get_address_of_address_0() { return &___address_0; }
inline void set_address_0(UInt16U5BU5D_t2D4BB1F8C486FF4359FFA7E4A76A8708A684543E* value)
{
___address_0 = value;
Il2CppCodeGenWriteBarrier((&___address_0), value);
}
inline static int32_t get_offset_of_scopeId_1() { return static_cast<int32_t>(offsetof(IPv6AddressFormatter_t451290B1C6FD64B6C59F95D99EDB4A9CC703BA90, ___scopeId_1)); }
inline int64_t get_scopeId_1() const { return ___scopeId_1; }
inline int64_t* get_address_of_scopeId_1() { return &___scopeId_1; }
inline void set_scopeId_1(int64_t value)
{
___scopeId_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Net.IPv6AddressFormatter
struct IPv6AddressFormatter_t451290B1C6FD64B6C59F95D99EDB4A9CC703BA90_marshaled_pinvoke
{
uint16_t* ___address_0;
int64_t ___scopeId_1;
};
// Native definition for COM marshalling of System.Net.IPv6AddressFormatter
struct IPv6AddressFormatter_t451290B1C6FD64B6C59F95D99EDB4A9CC703BA90_marshaled_com
{
uint16_t* ___address_0;
int64_t ___scopeId_1;
};
#endif // IPV6ADDRESSFORMATTER_T451290B1C6FD64B6C59F95D99EDB4A9CC703BA90_H
#ifndef X509CERTIFICATE2IMPL_T645108014422F6408EB87390317CD10710F129E7_H
#define X509CERTIFICATE2IMPL_T645108014422F6408EB87390317CD10710F129E7_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509Certificate2Impl
struct X509Certificate2Impl_t645108014422F6408EB87390317CD10710F129E7 : public X509CertificateImpl_t89610BFDE87B872143A4623CFC7F17275EB48313
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CERTIFICATE2IMPL_T645108014422F6408EB87390317CD10710F129E7_H
#ifndef X509CERTIFICATECOLLECTION_T824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833_H
#define X509CERTIFICATECOLLECTION_T824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509CertificateCollection
struct X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833 : public CollectionBase_tF5D4583FF325726066A9803839A04E9C0084ED01
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CERTIFICATECOLLECTION_T824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833_H
#ifndef X509EXTENSION_T223237DF0C323CC455D3A2634D977773D2F3818A_H
#define X509EXTENSION_T223237DF0C323CC455D3A2634D977773D2F3818A_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509Extension
struct X509Extension_t223237DF0C323CC455D3A2634D977773D2F3818A : public AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65
{
public:
// System.Boolean System.Security.Cryptography.X509Certificates.X509Extension::_critical
bool ____critical_2;
public:
inline static int32_t get_offset_of__critical_2() { return static_cast<int32_t>(offsetof(X509Extension_t223237DF0C323CC455D3A2634D977773D2F3818A, ____critical_2)); }
inline bool get__critical_2() const { return ____critical_2; }
inline bool* get_address_of__critical_2() { return &____critical_2; }
inline void set__critical_2(bool value)
{
____critical_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509EXTENSION_T223237DF0C323CC455D3A2634D977773D2F3818A_H
#ifndef SYSTEMEXCEPTION_T5380468142AA850BE4A341D7AF3EAB9C78746782_H
#define SYSTEMEXCEPTION_T5380468142AA850BE4A341D7AF3EAB9C78746782_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.SystemException
struct SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782 : public Exception_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SYSTEMEXCEPTION_T5380468142AA850BE4A341D7AF3EAB9C78746782_H
#ifndef ASSETFILENAMEEXTENSIONATTRIBUTE_T634736D44FACBB2E58C82ABE354A807BD77DEB03_H
#define ASSETFILENAMEEXTENSIONATTRIBUTE_T634736D44FACBB2E58C82ABE354A807BD77DEB03_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.AssetFileNameExtensionAttribute
struct AssetFileNameExtensionAttribute_t634736D44FACBB2E58C82ABE354A807BD77DEB03 : public Attribute_tF048C13FB3C8CFCC53F82290E4A3F621089F9A74
{
public:
// System.String UnityEngine.AssetFileNameExtensionAttribute::<preferredExtension>k__BackingField
String_t* ___U3CpreferredExtensionU3Ek__BackingField_0;
// System.Collections.Generic.IEnumerable`1<System.String> UnityEngine.AssetFileNameExtensionAttribute::<otherExtensions>k__BackingField
RuntimeObject* ___U3CotherExtensionsU3Ek__BackingField_1;
public:
inline static int32_t get_offset_of_U3CpreferredExtensionU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(AssetFileNameExtensionAttribute_t634736D44FACBB2E58C82ABE354A807BD77DEB03, ___U3CpreferredExtensionU3Ek__BackingField_0)); }
inline String_t* get_U3CpreferredExtensionU3Ek__BackingField_0() const { return ___U3CpreferredExtensionU3Ek__BackingField_0; }
inline String_t** get_address_of_U3CpreferredExtensionU3Ek__BackingField_0() { return &___U3CpreferredExtensionU3Ek__BackingField_0; }
inline void set_U3CpreferredExtensionU3Ek__BackingField_0(String_t* value)
{
___U3CpreferredExtensionU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CpreferredExtensionU3Ek__BackingField_0), value);
}
inline static int32_t get_offset_of_U3CotherExtensionsU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(AssetFileNameExtensionAttribute_t634736D44FACBB2E58C82ABE354A807BD77DEB03, ___U3CotherExtensionsU3Ek__BackingField_1)); }
inline RuntimeObject* get_U3CotherExtensionsU3Ek__BackingField_1() const { return ___U3CotherExtensionsU3Ek__BackingField_1; }
inline RuntimeObject** get_address_of_U3CotherExtensionsU3Ek__BackingField_1() { return &___U3CotherExtensionsU3Ek__BackingField_1; }
inline void set_U3CotherExtensionsU3Ek__BackingField_1(RuntimeObject* value)
{
___U3CotherExtensionsU3Ek__BackingField_1 = value;
Il2CppCodeGenWriteBarrier((&___U3CotherExtensionsU3Ek__BackingField_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASSETFILENAMEEXTENSIONATTRIBUTE_T634736D44FACBB2E58C82ABE354A807BD77DEB03_H
#ifndef GENERATEDBYOLDBINDINGSGENERATORATTRIBUTE_TF3386E1746F60B4E1D77C2167915FBB4B89BBA86_H
#define GENERATEDBYOLDBINDINGSGENERATORATTRIBUTE_TF3386E1746F60B4E1D77C2167915FBB4B89BBA86_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Scripting.GeneratedByOldBindingsGeneratorAttribute
struct GeneratedByOldBindingsGeneratorAttribute_tF3386E1746F60B4E1D77C2167915FBB4B89BBA86 : public Attribute_tF048C13FB3C8CFCC53F82290E4A3F621089F9A74
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // GENERATEDBYOLDBINDINGSGENERATORATTRIBUTE_TF3386E1746F60B4E1D77C2167915FBB4B89BBA86_H
#ifndef REQUIREDBYNATIVECODEATTRIBUTE_T949320E827C2BD269B3E686FE317A18835670AAE_H
#define REQUIREDBYNATIVECODEATTRIBUTE_T949320E827C2BD269B3E686FE317A18835670AAE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Scripting.RequiredByNativeCodeAttribute
struct RequiredByNativeCodeAttribute_t949320E827C2BD269B3E686FE317A18835670AAE : public Attribute_tF048C13FB3C8CFCC53F82290E4A3F621089F9A74
{
public:
// System.String UnityEngine.Scripting.RequiredByNativeCodeAttribute::<Name>k__BackingField
String_t* ___U3CNameU3Ek__BackingField_0;
// System.Boolean UnityEngine.Scripting.RequiredByNativeCodeAttribute::<Optional>k__BackingField
bool ___U3COptionalU3Ek__BackingField_1;
// System.Boolean UnityEngine.Scripting.RequiredByNativeCodeAttribute::<GenerateProxy>k__BackingField
bool ___U3CGenerateProxyU3Ek__BackingField_2;
public:
inline static int32_t get_offset_of_U3CNameU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(RequiredByNativeCodeAttribute_t949320E827C2BD269B3E686FE317A18835670AAE, ___U3CNameU3Ek__BackingField_0)); }
inline String_t* get_U3CNameU3Ek__BackingField_0() const { return ___U3CNameU3Ek__BackingField_0; }
inline String_t** get_address_of_U3CNameU3Ek__BackingField_0() { return &___U3CNameU3Ek__BackingField_0; }
inline void set_U3CNameU3Ek__BackingField_0(String_t* value)
{
___U3CNameU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CNameU3Ek__BackingField_0), value);
}
inline static int32_t get_offset_of_U3COptionalU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(RequiredByNativeCodeAttribute_t949320E827C2BD269B3E686FE317A18835670AAE, ___U3COptionalU3Ek__BackingField_1)); }
inline bool get_U3COptionalU3Ek__BackingField_1() const { return ___U3COptionalU3Ek__BackingField_1; }
inline bool* get_address_of_U3COptionalU3Ek__BackingField_1() { return &___U3COptionalU3Ek__BackingField_1; }
inline void set_U3COptionalU3Ek__BackingField_1(bool value)
{
___U3COptionalU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CGenerateProxyU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(RequiredByNativeCodeAttribute_t949320E827C2BD269B3E686FE317A18835670AAE, ___U3CGenerateProxyU3Ek__BackingField_2)); }
inline bool get_U3CGenerateProxyU3Ek__BackingField_2() const { return ___U3CGenerateProxyU3Ek__BackingField_2; }
inline bool* get_address_of_U3CGenerateProxyU3Ek__BackingField_2() { return &___U3CGenerateProxyU3Ek__BackingField_2; }
inline void set_U3CGenerateProxyU3Ek__BackingField_2(bool value)
{
___U3CGenerateProxyU3Ek__BackingField_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REQUIREDBYNATIVECODEATTRIBUTE_T949320E827C2BD269B3E686FE317A18835670AAE_H
#ifndef USEDBYNATIVECODEATTRIBUTE_T923F9A140847AF2F193AD1AB33143B8774797912_H
#define USEDBYNATIVECODEATTRIBUTE_T923F9A140847AF2F193AD1AB33143B8774797912_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Scripting.UsedByNativeCodeAttribute
struct UsedByNativeCodeAttribute_t923F9A140847AF2F193AD1AB33143B8774797912 : public Attribute_tF048C13FB3C8CFCC53F82290E4A3F621089F9A74
{
public:
// System.String UnityEngine.Scripting.UsedByNativeCodeAttribute::<Name>k__BackingField
String_t* ___U3CNameU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CNameU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(UsedByNativeCodeAttribute_t923F9A140847AF2F193AD1AB33143B8774797912, ___U3CNameU3Ek__BackingField_0)); }
inline String_t* get_U3CNameU3Ek__BackingField_0() const { return ___U3CNameU3Ek__BackingField_0; }
inline String_t** get_address_of_U3CNameU3Ek__BackingField_0() { return &___U3CNameU3Ek__BackingField_0; }
inline void set_U3CNameU3Ek__BackingField_0(String_t* value)
{
___U3CNameU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CNameU3Ek__BackingField_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // USEDBYNATIVECODEATTRIBUTE_T923F9A140847AF2F193AD1AB33143B8774797912_H
#ifndef THREADANDSERIALIZATIONSAFEATTRIBUTE_TC7AAA73802AAF871C176CF59656C030E5BFA87AA_H
#define THREADANDSERIALIZATIONSAFEATTRIBUTE_TC7AAA73802AAF871C176CF59656C030E5BFA87AA_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.ThreadAndSerializationSafeAttribute
struct ThreadAndSerializationSafeAttribute_tC7AAA73802AAF871C176CF59656C030E5BFA87AA : public Attribute_tF048C13FB3C8CFCC53F82290E4A3F621089F9A74
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // THREADANDSERIALIZATIONSAFEATTRIBUTE_TC7AAA73802AAF871C176CF59656C030E5BFA87AA_H
#ifndef U3CPRIVATEIMPLEMENTATIONDETAILSU3E_TD3F45A95FC1F3A32916F221D83F290D182AD6291_H
#define U3CPRIVATEIMPLEMENTATIONDETAILSU3E_TD3F45A95FC1F3A32916F221D83F290D182AD6291_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// <PrivateImplementationDetails>
struct U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291 : public RuntimeObject
{
public:
public:
};
struct U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291_StaticFields
{
public:
// <PrivateImplementationDetails>/__StaticArrayInitTypeSize=32 <PrivateImplementationDetails>::59F5BD34B6C013DEACC784F69C67E95150033A84
__StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA ___59F5BD34B6C013DEACC784F69C67E95150033A84_0;
// <PrivateImplementationDetails>/__StaticArrayInitTypeSize=32 <PrivateImplementationDetails>::C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536
__StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA ___C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_1;
// <PrivateImplementationDetails>/__StaticArrayInitTypeSize=128 <PrivateImplementationDetails>::CCEEADA43268372341F81AE0C9208C6856441C04
__StaticArrayInitTypeSizeU3D128_t4A42759E6E25B0C61E6036A661F4344DE92C2905 ___CCEEADA43268372341F81AE0C9208C6856441C04_2;
// System.Int64 <PrivateImplementationDetails>::E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78
int64_t ___E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_3;
public:
inline static int32_t get_offset_of_U359F5BD34B6C013DEACC784F69C67E95150033A84_0() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291_StaticFields, ___59F5BD34B6C013DEACC784F69C67E95150033A84_0)); }
inline __StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA get_U359F5BD34B6C013DEACC784F69C67E95150033A84_0() const { return ___59F5BD34B6C013DEACC784F69C67E95150033A84_0; }
inline __StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA * get_address_of_U359F5BD34B6C013DEACC784F69C67E95150033A84_0() { return &___59F5BD34B6C013DEACC784F69C67E95150033A84_0; }
inline void set_U359F5BD34B6C013DEACC784F69C67E95150033A84_0(__StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA value)
{
___59F5BD34B6C013DEACC784F69C67E95150033A84_0 = value;
}
inline static int32_t get_offset_of_C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_1() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291_StaticFields, ___C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_1)); }
inline __StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA get_C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_1() const { return ___C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_1; }
inline __StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA * get_address_of_C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_1() { return &___C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_1; }
inline void set_C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_1(__StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA value)
{
___C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_1 = value;
}
inline static int32_t get_offset_of_CCEEADA43268372341F81AE0C9208C6856441C04_2() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291_StaticFields, ___CCEEADA43268372341F81AE0C9208C6856441C04_2)); }
inline __StaticArrayInitTypeSizeU3D128_t4A42759E6E25B0C61E6036A661F4344DE92C2905 get_CCEEADA43268372341F81AE0C9208C6856441C04_2() const { return ___CCEEADA43268372341F81AE0C9208C6856441C04_2; }
inline __StaticArrayInitTypeSizeU3D128_t4A42759E6E25B0C61E6036A661F4344DE92C2905 * get_address_of_CCEEADA43268372341F81AE0C9208C6856441C04_2() { return &___CCEEADA43268372341F81AE0C9208C6856441C04_2; }
inline void set_CCEEADA43268372341F81AE0C9208C6856441C04_2(__StaticArrayInitTypeSizeU3D128_t4A42759E6E25B0C61E6036A661F4344DE92C2905 value)
{
___CCEEADA43268372341F81AE0C9208C6856441C04_2 = value;
}
inline static int32_t get_offset_of_E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_3() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291_StaticFields, ___E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_3)); }
inline int64_t get_E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_3() const { return ___E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_3; }
inline int64_t* get_address_of_E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_3() { return &___E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_3; }
inline void set_E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_3(int64_t value)
{
___E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CPRIVATEIMPLEMENTATIONDETAILSU3E_TD3F45A95FC1F3A32916F221D83F290D182AD6291_H
#ifndef MONOSSLPOLICYERRORS_T5F32A4E793EAB8B8A8128A6A3E7690D2E1F666C7_H
#define MONOSSLPOLICYERRORS_T5F32A4E793EAB8B8A8128A6A3E7690D2E1F666C7_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Mono.Security.Interface.MonoSslPolicyErrors
struct MonoSslPolicyErrors_t5F32A4E793EAB8B8A8128A6A3E7690D2E1F666C7
{
public:
// System.Int32 Mono.Security.Interface.MonoSslPolicyErrors::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(MonoSslPolicyErrors_t5F32A4E793EAB8B8A8128A6A3E7690D2E1F666C7, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MONOSSLPOLICYERRORS_T5F32A4E793EAB8B8A8128A6A3E7690D2E1F666C7_H
#ifndef INVALIDOPERATIONEXCEPTION_T0530E734D823F78310CAFAFA424CA5164D93A1F1_H
#define INVALIDOPERATIONEXCEPTION_T0530E734D823F78310CAFAFA424CA5164D93A1F1_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.InvalidOperationException
struct InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INVALIDOPERATIONEXCEPTION_T0530E734D823F78310CAFAFA424CA5164D93A1F1_H
#ifndef BYPASSELEMENTCOLLECTION_T5CCE032F76311FCEFC3128DA5A88D25568A234A7_H
#define BYPASSELEMENTCOLLECTION_T5CCE032F76311FCEFC3128DA5A88D25568A234A7_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.BypassElementCollection
struct BypassElementCollection_t5CCE032F76311FCEFC3128DA5A88D25568A234A7 : public ConfigurationElementCollection_tB0DA3194B9C1528D2627B291C79B560C68A78FCC
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BYPASSELEMENTCOLLECTION_T5CCE032F76311FCEFC3128DA5A88D25568A234A7_H
#ifndef CONNECTIONMANAGEMENTELEMENTCOLLECTION_T83F843AEC2D2354836CC863E346FE2ECFEED2572_H
#define CONNECTIONMANAGEMENTELEMENTCOLLECTION_T83F843AEC2D2354836CC863E346FE2ECFEED2572_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.ConnectionManagementElementCollection
struct ConnectionManagementElementCollection_t83F843AEC2D2354836CC863E346FE2ECFEED2572 : public ConfigurationElementCollection_tB0DA3194B9C1528D2627B291C79B560C68A78FCC
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONNECTIONMANAGEMENTELEMENTCOLLECTION_T83F843AEC2D2354836CC863E346FE2ECFEED2572_H
#ifndef CONNECTIONMANAGEMENTSECTION_TA88F9BAD144E401AB524A9579B50050140592447_H
#define CONNECTIONMANAGEMENTSECTION_TA88F9BAD144E401AB524A9579B50050140592447_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.ConnectionManagementSection
struct ConnectionManagementSection_tA88F9BAD144E401AB524A9579B50050140592447 : public ConfigurationSection_t044F68052218C8000611AE9ADD5F66E62A632B34
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONNECTIONMANAGEMENTSECTION_TA88F9BAD144E401AB524A9579B50050140592447_H
#ifndef DEFAULTPROXYSECTION_TB752851846FC0CEBA83C36C2BF6553211029AA3B_H
#define DEFAULTPROXYSECTION_TB752851846FC0CEBA83C36C2BF6553211029AA3B_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.DefaultProxySection
struct DefaultProxySection_tB752851846FC0CEBA83C36C2BF6553211029AA3B : public ConfigurationSection_t044F68052218C8000611AE9ADD5F66E62A632B34
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DEFAULTPROXYSECTION_TB752851846FC0CEBA83C36C2BF6553211029AA3B_H
#ifndef SETTINGSSECTION_T8BECD0EB76F1865B33D072DD368676A8D51840B3_H
#define SETTINGSSECTION_T8BECD0EB76F1865B33D072DD368676A8D51840B3_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.SettingsSection
struct SettingsSection_t8BECD0EB76F1865B33D072DD368676A8D51840B3 : public ConfigurationSection_t044F68052218C8000611AE9ADD5F66E62A632B34
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SETTINGSSECTION_T8BECD0EB76F1865B33D072DD368676A8D51840B3_H
#ifndef WEBREQUESTMODULEELEMENTCOLLECTION_T2A993B681E96AAF6A96CCB0458F0F0B99BFF51BE_H
#define WEBREQUESTMODULEELEMENTCOLLECTION_T2A993B681E96AAF6A96CCB0458F0F0B99BFF51BE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.WebRequestModuleElementCollection
struct WebRequestModuleElementCollection_t2A993B681E96AAF6A96CCB0458F0F0B99BFF51BE : public ConfigurationElementCollection_tB0DA3194B9C1528D2627B291C79B560C68A78FCC
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WEBREQUESTMODULEELEMENTCOLLECTION_T2A993B681E96AAF6A96CCB0458F0F0B99BFF51BE_H
#ifndef WEBREQUESTMODULESSECTION_T5E031F632797D2C7F0D394BCEE4BD0DF0ECA81BC_H
#define WEBREQUESTMODULESSECTION_T5E031F632797D2C7F0D394BCEE4BD0DF0ECA81BC_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Configuration.WebRequestModulesSection
struct WebRequestModulesSection_t5E031F632797D2C7F0D394BCEE4BD0DF0ECA81BC : public ConfigurationSection_t044F68052218C8000611AE9ADD5F66E62A632B34
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WEBREQUESTMODULESSECTION_T5E031F632797D2C7F0D394BCEE4BD0DF0ECA81BC_H
#ifndef AUTHENTICATEDSTREAM_T3DD09B1EB437BE77A9B0536EC26005B6914BF501_H
#define AUTHENTICATEDSTREAM_T3DD09B1EB437BE77A9B0536EC26005B6914BF501_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Security.AuthenticatedStream
struct AuthenticatedStream_t3DD09B1EB437BE77A9B0536EC26005B6914BF501 : public Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7
{
public:
// System.IO.Stream System.Net.Security.AuthenticatedStream::_InnerStream
Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7 * ____InnerStream_4;
// System.Boolean System.Net.Security.AuthenticatedStream::_LeaveStreamOpen
bool ____LeaveStreamOpen_5;
public:
inline static int32_t get_offset_of__InnerStream_4() { return static_cast<int32_t>(offsetof(AuthenticatedStream_t3DD09B1EB437BE77A9B0536EC26005B6914BF501, ____InnerStream_4)); }
inline Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7 * get__InnerStream_4() const { return ____InnerStream_4; }
inline Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7 ** get_address_of__InnerStream_4() { return &____InnerStream_4; }
inline void set__InnerStream_4(Stream_tFC50657DD5AAB87770987F9179D934A51D99D5E7 * value)
{
____InnerStream_4 = value;
Il2CppCodeGenWriteBarrier((&____InnerStream_4), value);
}
inline static int32_t get_offset_of__LeaveStreamOpen_5() { return static_cast<int32_t>(offsetof(AuthenticatedStream_t3DD09B1EB437BE77A9B0536EC26005B6914BF501, ____LeaveStreamOpen_5)); }
inline bool get__LeaveStreamOpen_5() const { return ____LeaveStreamOpen_5; }
inline bool* get_address_of__LeaveStreamOpen_5() { return &____LeaveStreamOpen_5; }
inline void set__LeaveStreamOpen_5(bool value)
{
____LeaveStreamOpen_5 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // AUTHENTICATEDSTREAM_T3DD09B1EB437BE77A9B0536EC26005B6914BF501_H
#ifndef ADDRESSFAMILY_TFA4F79FA7F299EBDF507F4811E6E5C3EEBF0850E_H
#define ADDRESSFAMILY_TFA4F79FA7F299EBDF507F4811E6E5C3EEBF0850E_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Sockets.AddressFamily
struct AddressFamily_tFA4F79FA7F299EBDF507F4811E6E5C3EEBF0850E
{
public:
// System.Int32 System.Net.Sockets.AddressFamily::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AddressFamily_tFA4F79FA7F299EBDF507F4811E6E5C3EEBF0850E, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ADDRESSFAMILY_TFA4F79FA7F299EBDF507F4811E6E5C3EEBF0850E_H
#ifndef SOCKETERROR_T0157BEC7F0A26C8FC31D392B2B7C6CFCD695D5E7_H
#define SOCKETERROR_T0157BEC7F0A26C8FC31D392B2B7C6CFCD695D5E7_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Sockets.SocketError
struct SocketError_t0157BEC7F0A26C8FC31D392B2B7C6CFCD695D5E7
{
public:
// System.Int32 System.Net.Sockets.SocketError::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SocketError_t0157BEC7F0A26C8FC31D392B2B7C6CFCD695D5E7, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SOCKETERROR_T0157BEC7F0A26C8FC31D392B2B7C6CFCD695D5E7_H
#ifndef EXTERNALEXCEPTION_T68841FD169C0CB00CC950EDA7E2A59540D65B1CE_H
#define EXTERNALEXCEPTION_T68841FD169C0CB00CC950EDA7E2A59540D65B1CE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.InteropServices.ExternalException
struct ExternalException_t68841FD169C0CB00CC950EDA7E2A59540D65B1CE : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // EXTERNALEXCEPTION_T68841FD169C0CB00CC950EDA7E2A59540D65B1CE_H
#ifndef ASNDECODESTATUS_T83139F58FFE08CE7DBCB990C9F30D2F2CA5BC0BB_H
#define ASNDECODESTATUS_T83139F58FFE08CE7DBCB990C9F30D2F2CA5BC0BB_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.AsnDecodeStatus
struct AsnDecodeStatus_t83139F58FFE08CE7DBCB990C9F30D2F2CA5BC0BB
{
public:
// System.Int32 System.Security.Cryptography.AsnDecodeStatus::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AsnDecodeStatus_t83139F58FFE08CE7DBCB990C9F30D2F2CA5BC0BB, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASNDECODESTATUS_T83139F58FFE08CE7DBCB990C9F30D2F2CA5BC0BB_H
#ifndef STORELOCATION_T5610361F4E31C5B2B42EE424C3E136BE2CA4C830_H
#define STORELOCATION_T5610361F4E31C5B2B42EE424C3E136BE2CA4C830_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.StoreLocation
struct StoreLocation_t5610361F4E31C5B2B42EE424C3E136BE2CA4C830
{
public:
// System.Int32 System.Security.Cryptography.X509Certificates.StoreLocation::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(StoreLocation_t5610361F4E31C5B2B42EE424C3E136BE2CA4C830, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STORELOCATION_T5610361F4E31C5B2B42EE424C3E136BE2CA4C830_H
#ifndef X509CERTIFICATE2COLLECTION_T14D64A5A2CFE4EA1782A417F975C2AB85BDA190D_H
#define X509CERTIFICATE2COLLECTION_T14D64A5A2CFE4EA1782A417F975C2AB85BDA190D_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509Certificate2Collection
struct X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D : public X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833
{
public:
public:
};
struct X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D_StaticFields
{
public:
// System.String[] System.Security.Cryptography.X509Certificates.X509Certificate2Collection::newline_split
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___newline_split_1;
public:
inline static int32_t get_offset_of_newline_split_1() { return static_cast<int32_t>(offsetof(X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D_StaticFields, ___newline_split_1)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_newline_split_1() const { return ___newline_split_1; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_newline_split_1() { return &___newline_split_1; }
inline void set_newline_split_1(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___newline_split_1 = value;
Il2CppCodeGenWriteBarrier((&___newline_split_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CERTIFICATE2COLLECTION_T14D64A5A2CFE4EA1782A417F975C2AB85BDA190D_H
#ifndef X509CHAINSTATUSFLAGS_T208E1E90A6014521B09653B6B237D045A8573E5B_H
#define X509CHAINSTATUSFLAGS_T208E1E90A6014521B09653B6B237D045A8573E5B_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509ChainStatusFlags
struct X509ChainStatusFlags_t208E1E90A6014521B09653B6B237D045A8573E5B
{
public:
// System.Int32 System.Security.Cryptography.X509Certificates.X509ChainStatusFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(X509ChainStatusFlags_t208E1E90A6014521B09653B6B237D045A8573E5B, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CHAINSTATUSFLAGS_T208E1E90A6014521B09653B6B237D045A8573E5B_H
#ifndef X509KEYUSAGEFLAGS_TAD6560EDDEB746BA983AE4E7ABC237A6178D6437_H
#define X509KEYUSAGEFLAGS_TAD6560EDDEB746BA983AE4E7ABC237A6178D6437_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509KeyUsageFlags
struct X509KeyUsageFlags_tAD6560EDDEB746BA983AE4E7ABC237A6178D6437
{
public:
// System.Int32 System.Security.Cryptography.X509Certificates.X509KeyUsageFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(X509KeyUsageFlags_tAD6560EDDEB746BA983AE4E7ABC237A6178D6437, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509KEYUSAGEFLAGS_TAD6560EDDEB746BA983AE4E7ABC237A6178D6437_H
#ifndef X509REVOCATIONFLAG_T8BF7FE53641A7A3C406E86857F3C80F0E25C3F4A_H
#define X509REVOCATIONFLAG_T8BF7FE53641A7A3C406E86857F3C80F0E25C3F4A_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509RevocationFlag
struct X509RevocationFlag_t8BF7FE53641A7A3C406E86857F3C80F0E25C3F4A
{
public:
// System.Int32 System.Security.Cryptography.X509Certificates.X509RevocationFlag::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(X509RevocationFlag_t8BF7FE53641A7A3C406E86857F3C80F0E25C3F4A, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509REVOCATIONFLAG_T8BF7FE53641A7A3C406E86857F3C80F0E25C3F4A_H
#ifndef X509REVOCATIONMODE_TEFEA8C7147423CC3363A4AF504853BD054A33BE7_H
#define X509REVOCATIONMODE_TEFEA8C7147423CC3363A4AF504853BD054A33BE7_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509RevocationMode
struct X509RevocationMode_tEFEA8C7147423CC3363A4AF504853BD054A33BE7
{
public:
// System.Int32 System.Security.Cryptography.X509Certificates.X509RevocationMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(X509RevocationMode_tEFEA8C7147423CC3363A4AF504853BD054A33BE7, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509REVOCATIONMODE_TEFEA8C7147423CC3363A4AF504853BD054A33BE7_H
#ifndef X509SUBJECTKEYIDENTIFIERHASHALGORITHM_T7928324BFDBB7B255970D50D0D8972FDFC981A0C_H
#define X509SUBJECTKEYIDENTIFIERHASHALGORITHM_T7928324BFDBB7B255970D50D0D8972FDFC981A0C_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509SubjectKeyIdentifierHashAlgorithm
struct X509SubjectKeyIdentifierHashAlgorithm_t7928324BFDBB7B255970D50D0D8972FDFC981A0C
{
public:
// System.Int32 System.Security.Cryptography.X509Certificates.X509SubjectKeyIdentifierHashAlgorithm::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(X509SubjectKeyIdentifierHashAlgorithm_t7928324BFDBB7B255970D50D0D8972FDFC981A0C, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509SUBJECTKEYIDENTIFIERHASHALGORITHM_T7928324BFDBB7B255970D50D0D8972FDFC981A0C_H
#ifndef X509VERIFICATIONFLAGS_T145010CF6C45EE6563E0874B82C2555025F7A20B_H
#define X509VERIFICATIONFLAGS_T145010CF6C45EE6563E0874B82C2555025F7A20B_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509VerificationFlags
struct X509VerificationFlags_t145010CF6C45EE6563E0874B82C2555025F7A20B
{
public:
// System.Int32 System.Security.Cryptography.X509Certificates.X509VerificationFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(X509VerificationFlags_t145010CF6C45EE6563E0874B82C2555025F7A20B, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509VERIFICATIONFLAGS_T145010CF6C45EE6563E0874B82C2555025F7A20B_H
#ifndef TIMESPAN_TA8069278ACE8A74D6DF7D514A9CD4432433F64C4_H
#define TIMESPAN_TA8069278ACE8A74D6DF7D514A9CD4432433F64C4_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TimeSpan
struct TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4
{
public:
// System.Int64 System.TimeSpan::_ticks
int64_t ____ticks_3;
public:
inline static int32_t get_offset_of__ticks_3() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4, ____ticks_3)); }
inline int64_t get__ticks_3() const { return ____ticks_3; }
inline int64_t* get_address_of__ticks_3() { return &____ticks_3; }
inline void set__ticks_3(int64_t value)
{
____ticks_3 = value;
}
};
struct TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields
{
public:
// System.TimeSpan System.TimeSpan::Zero
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 ___Zero_0;
// System.TimeSpan System.TimeSpan::MaxValue
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 ___MaxValue_1;
// System.TimeSpan System.TimeSpan::MinValue
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 ___MinValue_2;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyConfigChecked
bool ____legacyConfigChecked_4;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyMode
bool ____legacyMode_5;
public:
inline static int32_t get_offset_of_Zero_0() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields, ___Zero_0)); }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 get_Zero_0() const { return ___Zero_0; }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 * get_address_of_Zero_0() { return &___Zero_0; }
inline void set_Zero_0(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 value)
{
___Zero_0 = value;
}
inline static int32_t get_offset_of_MaxValue_1() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields, ___MaxValue_1)); }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 get_MaxValue_1() const { return ___MaxValue_1; }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 * get_address_of_MaxValue_1() { return &___MaxValue_1; }
inline void set_MaxValue_1(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 value)
{
___MaxValue_1 = value;
}
inline static int32_t get_offset_of_MinValue_2() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields, ___MinValue_2)); }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 get_MinValue_2() const { return ___MinValue_2; }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 * get_address_of_MinValue_2() { return &___MinValue_2; }
inline void set_MinValue_2(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 value)
{
___MinValue_2 = value;
}
inline static int32_t get_offset_of__legacyConfigChecked_4() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields, ____legacyConfigChecked_4)); }
inline bool get__legacyConfigChecked_4() const { return ____legacyConfigChecked_4; }
inline bool* get_address_of__legacyConfigChecked_4() { return &____legacyConfigChecked_4; }
inline void set__legacyConfigChecked_4(bool value)
{
____legacyConfigChecked_4 = value;
}
inline static int32_t get_offset_of__legacyMode_5() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields, ____legacyMode_5)); }
inline bool get__legacyMode_5() const { return ____legacyMode_5; }
inline bool* get_address_of__legacyMode_5() { return &____legacyMode_5; }
inline void set__legacyMode_5(bool value)
{
____legacyMode_5 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TIMESPAN_TA8069278ACE8A74D6DF7D514A9CD4432433F64C4_H
#ifndef WIN32EXCEPTION_TB05BE97AB4CADD54DF96C0109689F0ECA7517668_H
#define WIN32EXCEPTION_TB05BE97AB4CADD54DF96C0109689F0ECA7517668_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ComponentModel.Win32Exception
struct Win32Exception_tB05BE97AB4CADD54DF96C0109689F0ECA7517668 : public ExternalException_t68841FD169C0CB00CC950EDA7E2A59540D65B1CE
{
public:
// System.Int32 System.ComponentModel.Win32Exception::nativeErrorCode
int32_t ___nativeErrorCode_17;
public:
inline static int32_t get_offset_of_nativeErrorCode_17() { return static_cast<int32_t>(offsetof(Win32Exception_tB05BE97AB4CADD54DF96C0109689F0ECA7517668, ___nativeErrorCode_17)); }
inline int32_t get_nativeErrorCode_17() const { return ___nativeErrorCode_17; }
inline int32_t* get_address_of_nativeErrorCode_17() { return &___nativeErrorCode_17; }
inline void set_nativeErrorCode_17(int32_t value)
{
___nativeErrorCode_17 = value;
}
};
struct Win32Exception_tB05BE97AB4CADD54DF96C0109689F0ECA7517668_StaticFields
{
public:
// System.Boolean System.ComponentModel.Win32Exception::s_ErrorMessagesInitialized
bool ___s_ErrorMessagesInitialized_18;
// System.Collections.Generic.Dictionary`2<System.Int32,System.String> System.ComponentModel.Win32Exception::s_ErrorMessage
Dictionary_2_t4EFE6A1D6502662B911688316C6920444A18CF0C * ___s_ErrorMessage_19;
public:
inline static int32_t get_offset_of_s_ErrorMessagesInitialized_18() { return static_cast<int32_t>(offsetof(Win32Exception_tB05BE97AB4CADD54DF96C0109689F0ECA7517668_StaticFields, ___s_ErrorMessagesInitialized_18)); }
inline bool get_s_ErrorMessagesInitialized_18() const { return ___s_ErrorMessagesInitialized_18; }
inline bool* get_address_of_s_ErrorMessagesInitialized_18() { return &___s_ErrorMessagesInitialized_18; }
inline void set_s_ErrorMessagesInitialized_18(bool value)
{
___s_ErrorMessagesInitialized_18 = value;
}
inline static int32_t get_offset_of_s_ErrorMessage_19() { return static_cast<int32_t>(offsetof(Win32Exception_tB05BE97AB4CADD54DF96C0109689F0ECA7517668_StaticFields, ___s_ErrorMessage_19)); }
inline Dictionary_2_t4EFE6A1D6502662B911688316C6920444A18CF0C * get_s_ErrorMessage_19() const { return ___s_ErrorMessage_19; }
inline Dictionary_2_t4EFE6A1D6502662B911688316C6920444A18CF0C ** get_address_of_s_ErrorMessage_19() { return &___s_ErrorMessage_19; }
inline void set_s_ErrorMessage_19(Dictionary_2_t4EFE6A1D6502662B911688316C6920444A18CF0C * value)
{
___s_ErrorMessage_19 = value;
Il2CppCodeGenWriteBarrier((&___s_ErrorMessage_19), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WIN32EXCEPTION_TB05BE97AB4CADD54DF96C0109689F0ECA7517668_H
#ifndef IPADDRESS_T77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_H
#define IPADDRESS_T77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.IPAddress
struct IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE : public RuntimeObject
{
public:
// System.Int64 System.Net.IPAddress::m_Address
int64_t ___m_Address_5;
// System.String System.Net.IPAddress::m_ToString
String_t* ___m_ToString_6;
// System.Net.Sockets.AddressFamily System.Net.IPAddress::m_Family
int32_t ___m_Family_10;
// System.UInt16[] System.Net.IPAddress::m_Numbers
UInt16U5BU5D_t2D4BB1F8C486FF4359FFA7E4A76A8708A684543E* ___m_Numbers_11;
// System.Int64 System.Net.IPAddress::m_ScopeId
int64_t ___m_ScopeId_12;
// System.Int32 System.Net.IPAddress::m_HashCode
int32_t ___m_HashCode_13;
public:
inline static int32_t get_offset_of_m_Address_5() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE, ___m_Address_5)); }
inline int64_t get_m_Address_5() const { return ___m_Address_5; }
inline int64_t* get_address_of_m_Address_5() { return &___m_Address_5; }
inline void set_m_Address_5(int64_t value)
{
___m_Address_5 = value;
}
inline static int32_t get_offset_of_m_ToString_6() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE, ___m_ToString_6)); }
inline String_t* get_m_ToString_6() const { return ___m_ToString_6; }
inline String_t** get_address_of_m_ToString_6() { return &___m_ToString_6; }
inline void set_m_ToString_6(String_t* value)
{
___m_ToString_6 = value;
Il2CppCodeGenWriteBarrier((&___m_ToString_6), value);
}
inline static int32_t get_offset_of_m_Family_10() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE, ___m_Family_10)); }
inline int32_t get_m_Family_10() const { return ___m_Family_10; }
inline int32_t* get_address_of_m_Family_10() { return &___m_Family_10; }
inline void set_m_Family_10(int32_t value)
{
___m_Family_10 = value;
}
inline static int32_t get_offset_of_m_Numbers_11() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE, ___m_Numbers_11)); }
inline UInt16U5BU5D_t2D4BB1F8C486FF4359FFA7E4A76A8708A684543E* get_m_Numbers_11() const { return ___m_Numbers_11; }
inline UInt16U5BU5D_t2D4BB1F8C486FF4359FFA7E4A76A8708A684543E** get_address_of_m_Numbers_11() { return &___m_Numbers_11; }
inline void set_m_Numbers_11(UInt16U5BU5D_t2D4BB1F8C486FF4359FFA7E4A76A8708A684543E* value)
{
___m_Numbers_11 = value;
Il2CppCodeGenWriteBarrier((&___m_Numbers_11), value);
}
inline static int32_t get_offset_of_m_ScopeId_12() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE, ___m_ScopeId_12)); }
inline int64_t get_m_ScopeId_12() const { return ___m_ScopeId_12; }
inline int64_t* get_address_of_m_ScopeId_12() { return &___m_ScopeId_12; }
inline void set_m_ScopeId_12(int64_t value)
{
___m_ScopeId_12 = value;
}
inline static int32_t get_offset_of_m_HashCode_13() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE, ___m_HashCode_13)); }
inline int32_t get_m_HashCode_13() const { return ___m_HashCode_13; }
inline int32_t* get_address_of_m_HashCode_13() { return &___m_HashCode_13; }
inline void set_m_HashCode_13(int32_t value)
{
___m_HashCode_13 = value;
}
};
struct IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields
{
public:
// System.Net.IPAddress System.Net.IPAddress::Any
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * ___Any_0;
// System.Net.IPAddress System.Net.IPAddress::Loopback
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * ___Loopback_1;
// System.Net.IPAddress System.Net.IPAddress::Broadcast
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * ___Broadcast_2;
// System.Net.IPAddress System.Net.IPAddress::None
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * ___None_3;
// System.Net.IPAddress System.Net.IPAddress::IPv6Any
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * ___IPv6Any_7;
// System.Net.IPAddress System.Net.IPAddress::IPv6Loopback
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * ___IPv6Loopback_8;
// System.Net.IPAddress System.Net.IPAddress::IPv6None
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * ___IPv6None_9;
public:
inline static int32_t get_offset_of_Any_0() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields, ___Any_0)); }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * get_Any_0() const { return ___Any_0; }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE ** get_address_of_Any_0() { return &___Any_0; }
inline void set_Any_0(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * value)
{
___Any_0 = value;
Il2CppCodeGenWriteBarrier((&___Any_0), value);
}
inline static int32_t get_offset_of_Loopback_1() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields, ___Loopback_1)); }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * get_Loopback_1() const { return ___Loopback_1; }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE ** get_address_of_Loopback_1() { return &___Loopback_1; }
inline void set_Loopback_1(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * value)
{
___Loopback_1 = value;
Il2CppCodeGenWriteBarrier((&___Loopback_1), value);
}
inline static int32_t get_offset_of_Broadcast_2() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields, ___Broadcast_2)); }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * get_Broadcast_2() const { return ___Broadcast_2; }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE ** get_address_of_Broadcast_2() { return &___Broadcast_2; }
inline void set_Broadcast_2(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * value)
{
___Broadcast_2 = value;
Il2CppCodeGenWriteBarrier((&___Broadcast_2), value);
}
inline static int32_t get_offset_of_None_3() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields, ___None_3)); }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * get_None_3() const { return ___None_3; }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE ** get_address_of_None_3() { return &___None_3; }
inline void set_None_3(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * value)
{
___None_3 = value;
Il2CppCodeGenWriteBarrier((&___None_3), value);
}
inline static int32_t get_offset_of_IPv6Any_7() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields, ___IPv6Any_7)); }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * get_IPv6Any_7() const { return ___IPv6Any_7; }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE ** get_address_of_IPv6Any_7() { return &___IPv6Any_7; }
inline void set_IPv6Any_7(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * value)
{
___IPv6Any_7 = value;
Il2CppCodeGenWriteBarrier((&___IPv6Any_7), value);
}
inline static int32_t get_offset_of_IPv6Loopback_8() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields, ___IPv6Loopback_8)); }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * get_IPv6Loopback_8() const { return ___IPv6Loopback_8; }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE ** get_address_of_IPv6Loopback_8() { return &___IPv6Loopback_8; }
inline void set_IPv6Loopback_8(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * value)
{
___IPv6Loopback_8 = value;
Il2CppCodeGenWriteBarrier((&___IPv6Loopback_8), value);
}
inline static int32_t get_offset_of_IPv6None_9() { return static_cast<int32_t>(offsetof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields, ___IPv6None_9)); }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * get_IPv6None_9() const { return ___IPv6None_9; }
inline IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE ** get_address_of_IPv6None_9() { return &___IPv6None_9; }
inline void set_IPv6None_9(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE * value)
{
___IPv6None_9 = value;
Il2CppCodeGenWriteBarrier((&___IPv6None_9), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // IPADDRESS_T77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_H
#ifndef SSLSTREAM_T9CEE8F6E125C734DD807D9289C86860FFEE81087_H
#define SSLSTREAM_T9CEE8F6E125C734DD807D9289C86860FFEE81087_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Security.SslStream
struct SslStream_t9CEE8F6E125C734DD807D9289C86860FFEE81087 : public AuthenticatedStream_t3DD09B1EB437BE77A9B0536EC26005B6914BF501
{
public:
// Mono.Security.Interface.MonoTlsProvider System.Net.Security.SslStream::provider
MonoTlsProvider_tDCD056C5BBBE59ED6BAF63F25952B406C1143C27 * ___provider_6;
// Mono.Security.Interface.IMonoSslStream System.Net.Security.SslStream::impl
RuntimeObject* ___impl_7;
public:
inline static int32_t get_offset_of_provider_6() { return static_cast<int32_t>(offsetof(SslStream_t9CEE8F6E125C734DD807D9289C86860FFEE81087, ___provider_6)); }
inline MonoTlsProvider_tDCD056C5BBBE59ED6BAF63F25952B406C1143C27 * get_provider_6() const { return ___provider_6; }
inline MonoTlsProvider_tDCD056C5BBBE59ED6BAF63F25952B406C1143C27 ** get_address_of_provider_6() { return &___provider_6; }
inline void set_provider_6(MonoTlsProvider_tDCD056C5BBBE59ED6BAF63F25952B406C1143C27 * value)
{
___provider_6 = value;
Il2CppCodeGenWriteBarrier((&___provider_6), value);
}
inline static int32_t get_offset_of_impl_7() { return static_cast<int32_t>(offsetof(SslStream_t9CEE8F6E125C734DD807D9289C86860FFEE81087, ___impl_7)); }
inline RuntimeObject* get_impl_7() const { return ___impl_7; }
inline RuntimeObject** get_address_of_impl_7() { return &___impl_7; }
inline void set_impl_7(RuntimeObject* value)
{
___impl_7 = value;
Il2CppCodeGenWriteBarrier((&___impl_7), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SSLSTREAM_T9CEE8F6E125C734DD807D9289C86860FFEE81087_H
#ifndef OBJECTDISPOSEDEXCEPTION_TF68E471ECD1419AD7C51137B742837395F50B69A_H
#define OBJECTDISPOSEDEXCEPTION_TF68E471ECD1419AD7C51137B742837395F50B69A_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ObjectDisposedException
struct ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A : public InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1
{
public:
// System.String System.ObjectDisposedException::objectName
String_t* ___objectName_17;
public:
inline static int32_t get_offset_of_objectName_17() { return static_cast<int32_t>(offsetof(ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A, ___objectName_17)); }
inline String_t* get_objectName_17() const { return ___objectName_17; }
inline String_t** get_address_of_objectName_17() { return &___objectName_17; }
inline void set_objectName_17(String_t* value)
{
___objectName_17 = value;
Il2CppCodeGenWriteBarrier((&___objectName_17), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OBJECTDISPOSEDEXCEPTION_TF68E471ECD1419AD7C51137B742837395F50B69A_H
#ifndef X509BASICCONSTRAINTSEXTENSION_T091983B3CDCB686781B4853177610A22483B532C_H
#define X509BASICCONSTRAINTSEXTENSION_T091983B3CDCB686781B4853177610A22483B532C_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509BasicConstraintsExtension
struct X509BasicConstraintsExtension_t091983B3CDCB686781B4853177610A22483B532C : public X509Extension_t223237DF0C323CC455D3A2634D977773D2F3818A
{
public:
// System.Boolean System.Security.Cryptography.X509Certificates.X509BasicConstraintsExtension::_certificateAuthority
bool ____certificateAuthority_5;
// System.Boolean System.Security.Cryptography.X509Certificates.X509BasicConstraintsExtension::_hasPathLengthConstraint
bool ____hasPathLengthConstraint_6;
// System.Int32 System.Security.Cryptography.X509Certificates.X509BasicConstraintsExtension::_pathLengthConstraint
int32_t ____pathLengthConstraint_7;
// System.Security.Cryptography.AsnDecodeStatus System.Security.Cryptography.X509Certificates.X509BasicConstraintsExtension::_status
int32_t ____status_8;
public:
inline static int32_t get_offset_of__certificateAuthority_5() { return static_cast<int32_t>(offsetof(X509BasicConstraintsExtension_t091983B3CDCB686781B4853177610A22483B532C, ____certificateAuthority_5)); }
inline bool get__certificateAuthority_5() const { return ____certificateAuthority_5; }
inline bool* get_address_of__certificateAuthority_5() { return &____certificateAuthority_5; }
inline void set__certificateAuthority_5(bool value)
{
____certificateAuthority_5 = value;
}
inline static int32_t get_offset_of__hasPathLengthConstraint_6() { return static_cast<int32_t>(offsetof(X509BasicConstraintsExtension_t091983B3CDCB686781B4853177610A22483B532C, ____hasPathLengthConstraint_6)); }
inline bool get__hasPathLengthConstraint_6() const { return ____hasPathLengthConstraint_6; }
inline bool* get_address_of__hasPathLengthConstraint_6() { return &____hasPathLengthConstraint_6; }
inline void set__hasPathLengthConstraint_6(bool value)
{
____hasPathLengthConstraint_6 = value;
}
inline static int32_t get_offset_of__pathLengthConstraint_7() { return static_cast<int32_t>(offsetof(X509BasicConstraintsExtension_t091983B3CDCB686781B4853177610A22483B532C, ____pathLengthConstraint_7)); }
inline int32_t get__pathLengthConstraint_7() const { return ____pathLengthConstraint_7; }
inline int32_t* get_address_of__pathLengthConstraint_7() { return &____pathLengthConstraint_7; }
inline void set__pathLengthConstraint_7(int32_t value)
{
____pathLengthConstraint_7 = value;
}
inline static int32_t get_offset_of__status_8() { return static_cast<int32_t>(offsetof(X509BasicConstraintsExtension_t091983B3CDCB686781B4853177610A22483B532C, ____status_8)); }
inline int32_t get__status_8() const { return ____status_8; }
inline int32_t* get_address_of__status_8() { return &____status_8; }
inline void set__status_8(int32_t value)
{
____status_8 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509BASICCONSTRAINTSEXTENSION_T091983B3CDCB686781B4853177610A22483B532C_H
#ifndef X509CHAINIMPLMONO_T38D97B22EAE940C6D941DB58282503264F19FA9D_H
#define X509CHAINIMPLMONO_T38D97B22EAE940C6D941DB58282503264F19FA9D_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509ChainImplMono
struct X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D : public X509ChainImpl_t34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67
{
public:
// System.Security.Cryptography.X509Certificates.StoreLocation System.Security.Cryptography.X509Certificates.X509ChainImplMono::location
int32_t ___location_0;
// System.Security.Cryptography.X509Certificates.X509ChainElementCollection System.Security.Cryptography.X509Certificates.X509ChainImplMono::elements
X509ChainElementCollection_t7098FB9D22CA34D461370C124E598C629BCADBF4 * ___elements_1;
// System.Security.Cryptography.X509Certificates.X509ChainPolicy System.Security.Cryptography.X509Certificates.X509ChainImplMono::policy
X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD * ___policy_2;
public:
inline static int32_t get_offset_of_location_0() { return static_cast<int32_t>(offsetof(X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D, ___location_0)); }
inline int32_t get_location_0() const { return ___location_0; }
inline int32_t* get_address_of_location_0() { return &___location_0; }
inline void set_location_0(int32_t value)
{
___location_0 = value;
}
inline static int32_t get_offset_of_elements_1() { return static_cast<int32_t>(offsetof(X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D, ___elements_1)); }
inline X509ChainElementCollection_t7098FB9D22CA34D461370C124E598C629BCADBF4 * get_elements_1() const { return ___elements_1; }
inline X509ChainElementCollection_t7098FB9D22CA34D461370C124E598C629BCADBF4 ** get_address_of_elements_1() { return &___elements_1; }
inline void set_elements_1(X509ChainElementCollection_t7098FB9D22CA34D461370C124E598C629BCADBF4 * value)
{
___elements_1 = value;
Il2CppCodeGenWriteBarrier((&___elements_1), value);
}
inline static int32_t get_offset_of_policy_2() { return static_cast<int32_t>(offsetof(X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D, ___policy_2)); }
inline X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD * get_policy_2() const { return ___policy_2; }
inline X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD ** get_address_of_policy_2() { return &___policy_2; }
inline void set_policy_2(X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD * value)
{
___policy_2 = value;
Il2CppCodeGenWriteBarrier((&___policy_2), value);
}
};
struct X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D_StaticFields
{
public:
// System.Security.Cryptography.X509Certificates.X509ChainStatus[] System.Security.Cryptography.X509Certificates.X509ChainImplMono::Empty
X509ChainStatusU5BU5D_tA8CCC33D50C4BCF6F657063CD1DACCC3B9A7BFBB* ___Empty_3;
public:
inline static int32_t get_offset_of_Empty_3() { return static_cast<int32_t>(offsetof(X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D_StaticFields, ___Empty_3)); }
inline X509ChainStatusU5BU5D_tA8CCC33D50C4BCF6F657063CD1DACCC3B9A7BFBB* get_Empty_3() const { return ___Empty_3; }
inline X509ChainStatusU5BU5D_tA8CCC33D50C4BCF6F657063CD1DACCC3B9A7BFBB** get_address_of_Empty_3() { return &___Empty_3; }
inline void set_Empty_3(X509ChainStatusU5BU5D_tA8CCC33D50C4BCF6F657063CD1DACCC3B9A7BFBB* value)
{
___Empty_3 = value;
Il2CppCodeGenWriteBarrier((&___Empty_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CHAINIMPLMONO_T38D97B22EAE940C6D941DB58282503264F19FA9D_H
#ifndef X509CHAINPOLICY_TCA1D9E9842A16ACD71D35E9C36659E3E861D74DD_H
#define X509CHAINPOLICY_TCA1D9E9842A16ACD71D35E9C36659E3E861D74DD_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509ChainPolicy
struct X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD : public RuntimeObject
{
public:
// System.Security.Cryptography.OidCollection System.Security.Cryptography.X509Certificates.X509ChainPolicy::apps
OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E * ___apps_0;
// System.Security.Cryptography.OidCollection System.Security.Cryptography.X509Certificates.X509ChainPolicy::cert
OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E * ___cert_1;
// System.Security.Cryptography.X509Certificates.X509CertificateCollection System.Security.Cryptography.X509Certificates.X509ChainPolicy::store
X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833 * ___store_2;
// System.Security.Cryptography.X509Certificates.X509Certificate2Collection System.Security.Cryptography.X509Certificates.X509ChainPolicy::store2
X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D * ___store2_3;
// System.Security.Cryptography.X509Certificates.X509RevocationFlag System.Security.Cryptography.X509Certificates.X509ChainPolicy::rflag
int32_t ___rflag_4;
// System.Security.Cryptography.X509Certificates.X509RevocationMode System.Security.Cryptography.X509Certificates.X509ChainPolicy::mode
int32_t ___mode_5;
// System.TimeSpan System.Security.Cryptography.X509Certificates.X509ChainPolicy::timeout
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 ___timeout_6;
// System.Security.Cryptography.X509Certificates.X509VerificationFlags System.Security.Cryptography.X509Certificates.X509ChainPolicy::vflags
int32_t ___vflags_7;
// System.DateTime System.Security.Cryptography.X509Certificates.X509ChainPolicy::vtime
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 ___vtime_8;
public:
inline static int32_t get_offset_of_apps_0() { return static_cast<int32_t>(offsetof(X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD, ___apps_0)); }
inline OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E * get_apps_0() const { return ___apps_0; }
inline OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E ** get_address_of_apps_0() { return &___apps_0; }
inline void set_apps_0(OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E * value)
{
___apps_0 = value;
Il2CppCodeGenWriteBarrier((&___apps_0), value);
}
inline static int32_t get_offset_of_cert_1() { return static_cast<int32_t>(offsetof(X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD, ___cert_1)); }
inline OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E * get_cert_1() const { return ___cert_1; }
inline OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E ** get_address_of_cert_1() { return &___cert_1; }
inline void set_cert_1(OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E * value)
{
___cert_1 = value;
Il2CppCodeGenWriteBarrier((&___cert_1), value);
}
inline static int32_t get_offset_of_store_2() { return static_cast<int32_t>(offsetof(X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD, ___store_2)); }
inline X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833 * get_store_2() const { return ___store_2; }
inline X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833 ** get_address_of_store_2() { return &___store_2; }
inline void set_store_2(X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833 * value)
{
___store_2 = value;
Il2CppCodeGenWriteBarrier((&___store_2), value);
}
inline static int32_t get_offset_of_store2_3() { return static_cast<int32_t>(offsetof(X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD, ___store2_3)); }
inline X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D * get_store2_3() const { return ___store2_3; }
inline X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D ** get_address_of_store2_3() { return &___store2_3; }
inline void set_store2_3(X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D * value)
{
___store2_3 = value;
Il2CppCodeGenWriteBarrier((&___store2_3), value);
}
inline static int32_t get_offset_of_rflag_4() { return static_cast<int32_t>(offsetof(X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD, ___rflag_4)); }
inline int32_t get_rflag_4() const { return ___rflag_4; }
inline int32_t* get_address_of_rflag_4() { return &___rflag_4; }
inline void set_rflag_4(int32_t value)
{
___rflag_4 = value;
}
inline static int32_t get_offset_of_mode_5() { return static_cast<int32_t>(offsetof(X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD, ___mode_5)); }
inline int32_t get_mode_5() const { return ___mode_5; }
inline int32_t* get_address_of_mode_5() { return &___mode_5; }
inline void set_mode_5(int32_t value)
{
___mode_5 = value;
}
inline static int32_t get_offset_of_timeout_6() { return static_cast<int32_t>(offsetof(X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD, ___timeout_6)); }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 get_timeout_6() const { return ___timeout_6; }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 * get_address_of_timeout_6() { return &___timeout_6; }
inline void set_timeout_6(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 value)
{
___timeout_6 = value;
}
inline static int32_t get_offset_of_vflags_7() { return static_cast<int32_t>(offsetof(X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD, ___vflags_7)); }
inline int32_t get_vflags_7() const { return ___vflags_7; }
inline int32_t* get_address_of_vflags_7() { return &___vflags_7; }
inline void set_vflags_7(int32_t value)
{
___vflags_7 = value;
}
inline static int32_t get_offset_of_vtime_8() { return static_cast<int32_t>(offsetof(X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD, ___vtime_8)); }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 get_vtime_8() const { return ___vtime_8; }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 * get_address_of_vtime_8() { return &___vtime_8; }
inline void set_vtime_8(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 value)
{
___vtime_8 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CHAINPOLICY_TCA1D9E9842A16ACD71D35E9C36659E3E861D74DD_H
#ifndef X509CHAINSTATUS_T9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C_H
#define X509CHAINSTATUS_T9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509ChainStatus
struct X509ChainStatus_t9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C
{
public:
// System.Security.Cryptography.X509Certificates.X509ChainStatusFlags System.Security.Cryptography.X509Certificates.X509ChainStatus::status
int32_t ___status_0;
// System.String System.Security.Cryptography.X509Certificates.X509ChainStatus::info
String_t* ___info_1;
public:
inline static int32_t get_offset_of_status_0() { return static_cast<int32_t>(offsetof(X509ChainStatus_t9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C, ___status_0)); }
inline int32_t get_status_0() const { return ___status_0; }
inline int32_t* get_address_of_status_0() { return &___status_0; }
inline void set_status_0(int32_t value)
{
___status_0 = value;
}
inline static int32_t get_offset_of_info_1() { return static_cast<int32_t>(offsetof(X509ChainStatus_t9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C, ___info_1)); }
inline String_t* get_info_1() const { return ___info_1; }
inline String_t** get_address_of_info_1() { return &___info_1; }
inline void set_info_1(String_t* value)
{
___info_1 = value;
Il2CppCodeGenWriteBarrier((&___info_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Security.Cryptography.X509Certificates.X509ChainStatus
struct X509ChainStatus_t9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C_marshaled_pinvoke
{
int32_t ___status_0;
char* ___info_1;
};
// Native definition for COM marshalling of System.Security.Cryptography.X509Certificates.X509ChainStatus
struct X509ChainStatus_t9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C_marshaled_com
{
int32_t ___status_0;
Il2CppChar* ___info_1;
};
#endif // X509CHAINSTATUS_T9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C_H
#ifndef X509ENHANCEDKEYUSAGEEXTENSION_T8B1FEC5814799207635A97EA878EA64688437254_H
#define X509ENHANCEDKEYUSAGEEXTENSION_T8B1FEC5814799207635A97EA878EA64688437254_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509EnhancedKeyUsageExtension
struct X509EnhancedKeyUsageExtension_t8B1FEC5814799207635A97EA878EA64688437254 : public X509Extension_t223237DF0C323CC455D3A2634D977773D2F3818A
{
public:
// System.Security.Cryptography.OidCollection System.Security.Cryptography.X509Certificates.X509EnhancedKeyUsageExtension::_enhKeyUsage
OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E * ____enhKeyUsage_3;
// System.Security.Cryptography.AsnDecodeStatus System.Security.Cryptography.X509Certificates.X509EnhancedKeyUsageExtension::_status
int32_t ____status_4;
public:
inline static int32_t get_offset_of__enhKeyUsage_3() { return static_cast<int32_t>(offsetof(X509EnhancedKeyUsageExtension_t8B1FEC5814799207635A97EA878EA64688437254, ____enhKeyUsage_3)); }
inline OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E * get__enhKeyUsage_3() const { return ____enhKeyUsage_3; }
inline OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E ** get_address_of__enhKeyUsage_3() { return &____enhKeyUsage_3; }
inline void set__enhKeyUsage_3(OidCollection_tEB423F1150E53DCF513BF5A699F911586A31B94E * value)
{
____enhKeyUsage_3 = value;
Il2CppCodeGenWriteBarrier((&____enhKeyUsage_3), value);
}
inline static int32_t get_offset_of__status_4() { return static_cast<int32_t>(offsetof(X509EnhancedKeyUsageExtension_t8B1FEC5814799207635A97EA878EA64688437254, ____status_4)); }
inline int32_t get__status_4() const { return ____status_4; }
inline int32_t* get_address_of__status_4() { return &____status_4; }
inline void set__status_4(int32_t value)
{
____status_4 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509ENHANCEDKEYUSAGEEXTENSION_T8B1FEC5814799207635A97EA878EA64688437254_H
#ifndef X509KEYUSAGEEXTENSION_T9F740A60AD6DBEF9B09E946D4D8D67DB882C6E6E_H
#define X509KEYUSAGEEXTENSION_T9F740A60AD6DBEF9B09E946D4D8D67DB882C6E6E_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509KeyUsageExtension
struct X509KeyUsageExtension_t9F740A60AD6DBEF9B09E946D4D8D67DB882C6E6E : public X509Extension_t223237DF0C323CC455D3A2634D977773D2F3818A
{
public:
// System.Security.Cryptography.X509Certificates.X509KeyUsageFlags System.Security.Cryptography.X509Certificates.X509KeyUsageExtension::_keyUsages
int32_t ____keyUsages_6;
// System.Security.Cryptography.AsnDecodeStatus System.Security.Cryptography.X509Certificates.X509KeyUsageExtension::_status
int32_t ____status_7;
public:
inline static int32_t get_offset_of__keyUsages_6() { return static_cast<int32_t>(offsetof(X509KeyUsageExtension_t9F740A60AD6DBEF9B09E946D4D8D67DB882C6E6E, ____keyUsages_6)); }
inline int32_t get__keyUsages_6() const { return ____keyUsages_6; }
inline int32_t* get_address_of__keyUsages_6() { return &____keyUsages_6; }
inline void set__keyUsages_6(int32_t value)
{
____keyUsages_6 = value;
}
inline static int32_t get_offset_of__status_7() { return static_cast<int32_t>(offsetof(X509KeyUsageExtension_t9F740A60AD6DBEF9B09E946D4D8D67DB882C6E6E, ____status_7)); }
inline int32_t get__status_7() const { return ____status_7; }
inline int32_t* get_address_of__status_7() { return &____status_7; }
inline void set__status_7(int32_t value)
{
____status_7 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509KEYUSAGEEXTENSION_T9F740A60AD6DBEF9B09E946D4D8D67DB882C6E6E_H
#ifndef X509SUBJECTKEYIDENTIFIEREXTENSION_T200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E_H
#define X509SUBJECTKEYIDENTIFIEREXTENSION_T200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509SubjectKeyIdentifierExtension
struct X509SubjectKeyIdentifierExtension_t200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E : public X509Extension_t223237DF0C323CC455D3A2634D977773D2F3818A
{
public:
// System.Byte[] System.Security.Cryptography.X509Certificates.X509SubjectKeyIdentifierExtension::_subjectKeyIdentifier
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ____subjectKeyIdentifier_5;
// System.String System.Security.Cryptography.X509Certificates.X509SubjectKeyIdentifierExtension::_ski
String_t* ____ski_6;
// System.Security.Cryptography.AsnDecodeStatus System.Security.Cryptography.X509Certificates.X509SubjectKeyIdentifierExtension::_status
int32_t ____status_7;
public:
inline static int32_t get_offset_of__subjectKeyIdentifier_5() { return static_cast<int32_t>(offsetof(X509SubjectKeyIdentifierExtension_t200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E, ____subjectKeyIdentifier_5)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get__subjectKeyIdentifier_5() const { return ____subjectKeyIdentifier_5; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of__subjectKeyIdentifier_5() { return &____subjectKeyIdentifier_5; }
inline void set__subjectKeyIdentifier_5(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
____subjectKeyIdentifier_5 = value;
Il2CppCodeGenWriteBarrier((&____subjectKeyIdentifier_5), value);
}
inline static int32_t get_offset_of__ski_6() { return static_cast<int32_t>(offsetof(X509SubjectKeyIdentifierExtension_t200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E, ____ski_6)); }
inline String_t* get__ski_6() const { return ____ski_6; }
inline String_t** get_address_of__ski_6() { return &____ski_6; }
inline void set__ski_6(String_t* value)
{
____ski_6 = value;
Il2CppCodeGenWriteBarrier((&____ski_6), value);
}
inline static int32_t get_offset_of__status_7() { return static_cast<int32_t>(offsetof(X509SubjectKeyIdentifierExtension_t200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E, ____status_7)); }
inline int32_t get__status_7() const { return ____status_7; }
inline int32_t* get_address_of__status_7() { return &____status_7; }
inline void set__status_7(int32_t value)
{
____status_7 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509SUBJECTKEYIDENTIFIEREXTENSION_T200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E_H
#ifndef SOCKETEXCEPTION_T75481CF49BCAF5685A5A9E6933909E0B65E7E0A5_H
#define SOCKETEXCEPTION_T75481CF49BCAF5685A5A9E6933909E0B65E7E0A5_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Net.Sockets.SocketException
struct SocketException_t75481CF49BCAF5685A5A9E6933909E0B65E7E0A5 : public Win32Exception_tB05BE97AB4CADD54DF96C0109689F0ECA7517668
{
public:
// System.Net.EndPoint System.Net.Sockets.SocketException::m_EndPoint
EndPoint_tD87FCEF2780A951E8CE8D808C345FBF2C088D980 * ___m_EndPoint_20;
public:
inline static int32_t get_offset_of_m_EndPoint_20() { return static_cast<int32_t>(offsetof(SocketException_t75481CF49BCAF5685A5A9E6933909E0B65E7E0A5, ___m_EndPoint_20)); }
inline EndPoint_tD87FCEF2780A951E8CE8D808C345FBF2C088D980 * get_m_EndPoint_20() const { return ___m_EndPoint_20; }
inline EndPoint_tD87FCEF2780A951E8CE8D808C345FBF2C088D980 ** get_address_of_m_EndPoint_20() { return &___m_EndPoint_20; }
inline void set_m_EndPoint_20(EndPoint_tD87FCEF2780A951E8CE8D808C345FBF2C088D980 * value)
{
___m_EndPoint_20 = value;
Il2CppCodeGenWriteBarrier((&___m_EndPoint_20), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SOCKETEXCEPTION_T75481CF49BCAF5685A5A9E6933909E0B65E7E0A5_H
#ifndef THROWSTUB_T03526C535287FADF58CBFA05084AE89A0ACFFEFA_H
#define THROWSTUB_T03526C535287FADF58CBFA05084AE89A0ACFFEFA_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Unity.ThrowStub
struct ThrowStub_t03526C535287FADF58CBFA05084AE89A0ACFFEFA : public ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // THROWSTUB_T03526C535287FADF58CBFA05084AE89A0ACFFEFA_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1600 = { sizeof (AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1600[2] =
{
AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65::get_offset_of__oid_0(),
AsnEncodedData_t7D5EF5337DCAF507CAD7D750552C943F037A9D65::get_offset_of__raw_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1601 = { sizeof (StoreLocation_t5610361F4E31C5B2B42EE424C3E136BE2CA4C830)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable1601[3] =
{
StoreLocation_t5610361F4E31C5B2B42EE424C3E136BE2CA4C830::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1602 = { sizeof (X509ChainStatusFlags_t208E1E90A6014521B09653B6B237D045A8573E5B)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable1602[27] =
{
X509ChainStatusFlags_t208E1E90A6014521B09653B6B237D045A8573E5B::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1603 = { sizeof (X509KeyUsageFlags_tAD6560EDDEB746BA983AE4E7ABC237A6178D6437)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable1603[11] =
{
X509KeyUsageFlags_tAD6560EDDEB746BA983AE4E7ABC237A6178D6437::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1604 = { sizeof (X509RevocationFlag_t8BF7FE53641A7A3C406E86857F3C80F0E25C3F4A)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable1604[4] =
{
X509RevocationFlag_t8BF7FE53641A7A3C406E86857F3C80F0E25C3F4A::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1605 = { sizeof (X509RevocationMode_tEFEA8C7147423CC3363A4AF504853BD054A33BE7)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable1605[4] =
{
X509RevocationMode_tEFEA8C7147423CC3363A4AF504853BD054A33BE7::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1606 = { sizeof (X509SubjectKeyIdentifierHashAlgorithm_t7928324BFDBB7B255970D50D0D8972FDFC981A0C)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable1606[4] =
{
X509SubjectKeyIdentifierHashAlgorithm_t7928324BFDBB7B255970D50D0D8972FDFC981A0C::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1607 = { sizeof (X509VerificationFlags_t145010CF6C45EE6563E0874B82C2555025F7A20B)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable1607[15] =
{
X509VerificationFlags_t145010CF6C45EE6563E0874B82C2555025F7A20B::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1608 = { sizeof (X509Utils_t596E1974703C7988010495E60F15BE9680FC71B8), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1609 = { sizeof (PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620), -1, sizeof(PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable1609[4] =
{
PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620::get_offset_of__keyValue_0(),
PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620::get_offset_of__params_1(),
PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620::get_offset_of__oid_2(),
PublicKey_tBA8234EB603A903FCBBBE67D8247393D4CC8D620_StaticFields::get_offset_of_Empty_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1610 = { sizeof (X509BasicConstraintsExtension_t091983B3CDCB686781B4853177610A22483B532C), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1610[6] =
{
0,
0,
X509BasicConstraintsExtension_t091983B3CDCB686781B4853177610A22483B532C::get_offset_of__certificateAuthority_5(),
X509BasicConstraintsExtension_t091983B3CDCB686781B4853177610A22483B532C::get_offset_of__hasPathLengthConstraint_6(),
X509BasicConstraintsExtension_t091983B3CDCB686781B4853177610A22483B532C::get_offset_of__pathLengthConstraint_7(),
X509BasicConstraintsExtension_t091983B3CDCB686781B4853177610A22483B532C::get_offset_of__status_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1611 = { sizeof (X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D), -1, sizeof(X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable1611[1] =
{
X509Certificate2Collection_t14D64A5A2CFE4EA1782A417F975C2AB85BDA190D_StaticFields::get_offset_of_newline_split_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1612 = { sizeof (X509Certificate2Impl_t645108014422F6408EB87390317CD10710F129E7), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1613 = { sizeof (X509CertificateCollection_t824A6C58D0D1B4A7CAE30F26CE8EE4B23A8A1833), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1614 = { sizeof (X509CertificateEnumerator_t99AEDECD77BFC6083D8C98F9760BF7876D5B886B), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1614[1] =
{
X509CertificateEnumerator_t99AEDECD77BFC6083D8C98F9760BF7876D5B886B::get_offset_of_enumerator_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1615 = { sizeof (X509CertificateImplCollection_t2F7A6E9F160116CE64224D56187C92ECD7FA7242), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1615[1] =
{
X509CertificateImplCollection_t2F7A6E9F160116CE64224D56187C92ECD7FA7242::get_offset_of_list_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1616 = { sizeof (X509Chain_t4A28E9A30CBB331C9B68AE4AFCB30625C6C8B538), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1616[1] =
{
X509Chain_t4A28E9A30CBB331C9B68AE4AFCB30625C6C8B538::get_offset_of_impl_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1617 = { sizeof (X509ChainElementCollection_t7098FB9D22CA34D461370C124E598C629BCADBF4), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1617[1] =
{
X509ChainElementCollection_t7098FB9D22CA34D461370C124E598C629BCADBF4::get_offset_of__list_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1618 = { sizeof (X509ChainElementEnumerator_tEF7D4F9F87BAAF9A067923B6D4686C2AA4DB5B20), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1618[1] =
{
X509ChainElementEnumerator_tEF7D4F9F87BAAF9A067923B6D4686C2AA4DB5B20::get_offset_of_enumerator_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1619 = { sizeof (X509ChainImpl_t34FABF07BEA0CFB6D88717BCDDE0607D9DA13A67), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1620 = { sizeof (X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D), -1, sizeof(X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable1620[4] =
{
X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D::get_offset_of_location_0(),
X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D::get_offset_of_elements_1(),
X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D::get_offset_of_policy_2(),
X509ChainImplMono_t38D97B22EAE940C6D941DB58282503264F19FA9D_StaticFields::get_offset_of_Empty_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1621 = { sizeof (X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1621[9] =
{
X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD::get_offset_of_apps_0(),
X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD::get_offset_of_cert_1(),
X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD::get_offset_of_store_2(),
X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD::get_offset_of_store2_3(),
X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD::get_offset_of_rflag_4(),
X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD::get_offset_of_mode_5(),
X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD::get_offset_of_timeout_6(),
X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD::get_offset_of_vflags_7(),
X509ChainPolicy_tCA1D9E9842A16ACD71D35E9C36659E3E861D74DD::get_offset_of_vtime_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1622 = { sizeof (X509ChainStatus_t9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C)+ sizeof (RuntimeObject), sizeof(X509ChainStatus_t9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable1622[2] =
{
X509ChainStatus_t9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C::get_offset_of_status_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
X509ChainStatus_t9E05BD8700EA6158AC82F71CBE53AD20F6B99B0C::get_offset_of_info_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1623 = { sizeof (X509EnhancedKeyUsageExtension_t8B1FEC5814799207635A97EA878EA64688437254), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1623[2] =
{
X509EnhancedKeyUsageExtension_t8B1FEC5814799207635A97EA878EA64688437254::get_offset_of__enhKeyUsage_3(),
X509EnhancedKeyUsageExtension_t8B1FEC5814799207635A97EA878EA64688437254::get_offset_of__status_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1624 = { sizeof (X509Extension_t223237DF0C323CC455D3A2634D977773D2F3818A), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1624[1] =
{
X509Extension_t223237DF0C323CC455D3A2634D977773D2F3818A::get_offset_of__critical_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1625 = { sizeof (X509Helper2_tD0B65FDE6197798D9719F42AAEA8D9063A8916C7), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1626 = { sizeof (X509KeyUsageExtension_t9F740A60AD6DBEF9B09E946D4D8D67DB882C6E6E), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1626[5] =
{
0,
0,
0,
X509KeyUsageExtension_t9F740A60AD6DBEF9B09E946D4D8D67DB882C6E6E::get_offset_of__keyUsages_6(),
X509KeyUsageExtension_t9F740A60AD6DBEF9B09E946D4D8D67DB882C6E6E::get_offset_of__status_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1627 = { sizeof (X509SubjectKeyIdentifierExtension_t200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1627[5] =
{
0,
0,
X509SubjectKeyIdentifierExtension_t200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E::get_offset_of__subjectKeyIdentifier_5(),
X509SubjectKeyIdentifierExtension_t200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E::get_offset_of__ski_6(),
X509SubjectKeyIdentifierExtension_t200DBBEB1229862DAA5F56EA352B03D2EDAC4D8E::get_offset_of__status_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1628 = { sizeof (EndPoint_tD87FCEF2780A951E8CE8D808C345FBF2C088D980), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1629 = { sizeof (IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE), -1, sizeof(IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable1629[17] =
{
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields::get_offset_of_Any_0(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields::get_offset_of_Loopback_1(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields::get_offset_of_Broadcast_2(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields::get_offset_of_None_3(),
0,
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE::get_offset_of_m_Address_5(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE::get_offset_of_m_ToString_6(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields::get_offset_of_IPv6Any_7(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields::get_offset_of_IPv6Loopback_8(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE_StaticFields::get_offset_of_IPv6None_9(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE::get_offset_of_m_Family_10(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE::get_offset_of_m_Numbers_11(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE::get_offset_of_m_ScopeId_12(),
IPAddress_t77F35D21A3027F0CE7B38EA9B56BFD31B28952CE::get_offset_of_m_HashCode_13(),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1630 = { sizeof (IPv6AddressFormatter_t451290B1C6FD64B6C59F95D99EDB4A9CC703BA90)+ sizeof (RuntimeObject), sizeof(IPv6AddressFormatter_t451290B1C6FD64B6C59F95D99EDB4A9CC703BA90_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable1630[2] =
{
IPv6AddressFormatter_t451290B1C6FD64B6C59F95D99EDB4A9CC703BA90::get_offset_of_address_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
IPv6AddressFormatter_t451290B1C6FD64B6C59F95D99EDB4A9CC703BA90::get_offset_of_scopeId_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1631 = { sizeof (SocketException_t75481CF49BCAF5685A5A9E6933909E0B65E7E0A5), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1631[1] =
{
SocketException_t75481CF49BCAF5685A5A9E6933909E0B65E7E0A5::get_offset_of_m_EndPoint_20(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1632 = { sizeof (AddressFamily_tFA4F79FA7F299EBDF507F4811E6E5C3EEBF0850E)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable1632[32] =
{
AddressFamily_tFA4F79FA7F299EBDF507F4811E6E5C3EEBF0850E::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1633 = { sizeof (SocketError_t0157BEC7F0A26C8FC31D392B2B7C6CFCD695D5E7)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable1633[48] =
{
SocketError_t0157BEC7F0A26C8FC31D392B2B7C6CFCD695D5E7::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1634 = { sizeof (AuthenticatedStream_t3DD09B1EB437BE77A9B0536EC26005B6914BF501), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1634[2] =
{
AuthenticatedStream_t3DD09B1EB437BE77A9B0536EC26005B6914BF501::get_offset_of__InnerStream_4(),
AuthenticatedStream_t3DD09B1EB437BE77A9B0536EC26005B6914BF501::get_offset_of__LeaveStreamOpen_5(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1635 = { sizeof (SslStream_t9CEE8F6E125C734DD807D9289C86860FFEE81087), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1635[2] =
{
SslStream_t9CEE8F6E125C734DD807D9289C86860FFEE81087::get_offset_of_provider_6(),
SslStream_t9CEE8F6E125C734DD807D9289C86860FFEE81087::get_offset_of_impl_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1636 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1637 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1637[8] =
{
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1638 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1638[5] =
{
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1639 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1639[4] =
{
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1640 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1640[6] =
{
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1641 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1641[4] =
{
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1642 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1643 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1643[4] =
{
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1644 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1644[4] =
{
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1645 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1646 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1647 = { sizeof (U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291), -1, sizeof(U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable1647[4] =
{
U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291_StaticFields::get_offset_of_U359F5BD34B6C013DEACC784F69C67E95150033A84_0(),
U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291_StaticFields::get_offset_of_C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_1(),
U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291_StaticFields::get_offset_of_CCEEADA43268372341F81AE0C9208C6856441C04_2(),
U3CPrivateImplementationDetailsU3E_tD3F45A95FC1F3A32916F221D83F290D182AD6291_StaticFields::get_offset_of_E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1648 = { sizeof (__StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA)+ sizeof (RuntimeObject), sizeof(__StaticArrayInitTypeSizeU3D32_t5300E5FCBD58716E8A4EBB9470E4FAE1A0A964FA ), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1649 = { sizeof (__StaticArrayInitTypeSizeU3D128_t4A42759E6E25B0C61E6036A661F4344DE92C2905)+ sizeof (RuntimeObject), sizeof(__StaticArrayInitTypeSizeU3D128_t4A42759E6E25B0C61E6036A661F4344DE92C2905 ), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1650 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1651 = { sizeof (BypassElement_t89C59A549C7A25609AA5C200352CD9E310172BAF), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1652 = { sizeof (BypassElementCollection_t5CCE032F76311FCEFC3128DA5A88D25568A234A7), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1653 = { sizeof (ConnectionManagementElement_tABDA95F63A9CBFC2720D7D3F15C5B352EC5CE7AD), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1654 = { sizeof (ConnectionManagementElementCollection_t83F843AEC2D2354836CC863E346FE2ECFEED2572), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1655 = { sizeof (ConnectionManagementSection_tA88F9BAD144E401AB524A9579B50050140592447), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1656 = { sizeof (DefaultProxySection_tB752851846FC0CEBA83C36C2BF6553211029AA3B), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1657 = { sizeof (ProxyElement_tBD5D75620576BA5BB5521C11D09E0A6E996F9449), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1658 = { sizeof (HttpWebRequestElement_t3E2FC0EB83C362CC92300949AF90A0B0BE01EA3D), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1659 = { sizeof (Ipv6Element_tCA869DC79FE3740DBDECC47877F1676294DB4A23), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1660 = { sizeof (NetSectionGroup_tA4ACD82AFE8B5C11E509FA8623D554BB5B4DB591), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1661 = { sizeof (SettingsSection_t8BECD0EB76F1865B33D072DD368676A8D51840B3), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1662 = { sizeof (PerformanceCountersElement_tCE4CFF0A3503E44D7B8EC6E85FD3C50EB1A1B570), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1663 = { sizeof (ServicePointManagerElement_tD8D1491569C963460C14DF4D42ED05DF34428CFC), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1664 = { sizeof (SocketElement_t32F016077CBED287B80063811E80BCCC7E8B1BF9), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1665 = { sizeof (WebProxyScriptElement_t4302A26A6D4E02146662B30E3452A5167966E6B3), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1666 = { sizeof (WebRequestModulesSection_t5E031F632797D2C7F0D394BCEE4BD0DF0ECA81BC), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1667 = { sizeof (WebRequestModuleElementCollection_t2A993B681E96AAF6A96CCB0458F0F0B99BFF51BE), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1668 = { sizeof (WebRequestModuleElement_tE81A1FA5B9B4BCFB1ED015287A2D4F9EED37F3EC), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1669 = { sizeof (DiagnosticsConfigurationHandler_t885EAAD2DCF9678F16E3BB296E307868ECE68239), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1670 = { sizeof (ThrowStub_t03526C535287FADF58CBFA05084AE89A0ACFFEFA), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1671 = { sizeof (U3CModuleU3E_t239CA80C3AF3E763FA4B9A9F3CFADF0768B426EE), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1672 = { sizeof (ASN1_t2B883D12D3493F8395B31D1F0ABD93F43948B27E), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1672[3] =
{
ASN1_t2B883D12D3493F8395B31D1F0ABD93F43948B27E::get_offset_of_m_nTag_0(),
ASN1_t2B883D12D3493F8395B31D1F0ABD93F43948B27E::get_offset_of_m_aValue_1(),
ASN1_t2B883D12D3493F8395B31D1F0ABD93F43948B27E::get_offset_of_elist_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1673 = { sizeof (ASN1Convert_t5F783CA2300717B94F27A342A75A0E57B73FCC05), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1674 = { sizeof (BitConverterLE_t4CE9DF1164753ED72B6F4F33581C35FBCAEEC109), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1675 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1676 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1677 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1678 = { sizeof (MonoSslPolicyErrors_t5F32A4E793EAB8B8A8128A6A3E7690D2E1F666C7)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable1678[5] =
{
MonoSslPolicyErrors_t5F32A4E793EAB8B8A8128A6A3E7690D2E1F666C7::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1679 = { sizeof (MonoTlsProvider_tDCD056C5BBBE59ED6BAF63F25952B406C1143C27), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1680 = { sizeof (MonoTlsSettings_t5905C7532C92A87F88C8F3440165DF8AA49A1BBF), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1680[1] =
{
MonoTlsSettings_t5905C7532C92A87F88C8F3440165DF8AA49A1BBF::get_offset_of_U3CTrustAnchorsU3Ek__BackingField_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1681 = { sizeof (CryptoConvert_tF1F175C2F2C9E65FE7D5FBF0D434B964E4CAFF76), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1682 = { sizeof (U3CModuleU3E_t3EC8D1595A762E18CA2FD2325511B3DE2C4947AA), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1683 = { sizeof (Error_tDED49FF03F09C0230D8754901206DAAF2D798834), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1684 = { sizeof (Enumerable_tECC271C86C6E8F72E4E27C7C8FD5DB7B63D5D737), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1685 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1685[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1686 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1686[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1687 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1687[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1688 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1688[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1689 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1689[2] =
{
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1690 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1690[15] =
{
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1691 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1691[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1692 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable1692[4] =
{
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1693 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1694 = { sizeof (U3CModuleU3E_tDD607E0208590BE5D73D68EB7825AD7A1FBDFCC3), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1695 = { sizeof (UsedByNativeCodeAttribute_t923F9A140847AF2F193AD1AB33143B8774797912), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1695[1] =
{
UsedByNativeCodeAttribute_t923F9A140847AF2F193AD1AB33143B8774797912::get_offset_of_U3CNameU3Ek__BackingField_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1696 = { sizeof (RequiredByNativeCodeAttribute_t949320E827C2BD269B3E686FE317A18835670AAE), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1696[3] =
{
RequiredByNativeCodeAttribute_t949320E827C2BD269B3E686FE317A18835670AAE::get_offset_of_U3CNameU3Ek__BackingField_0(),
RequiredByNativeCodeAttribute_t949320E827C2BD269B3E686FE317A18835670AAE::get_offset_of_U3COptionalU3Ek__BackingField_1(),
RequiredByNativeCodeAttribute_t949320E827C2BD269B3E686FE317A18835670AAE::get_offset_of_U3CGenerateProxyU3Ek__BackingField_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1697 = { sizeof (GeneratedByOldBindingsGeneratorAttribute_tF3386E1746F60B4E1D77C2167915FBB4B89BBA86), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1698 = { sizeof (AssetFileNameExtensionAttribute_t634736D44FACBB2E58C82ABE354A807BD77DEB03), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable1698[2] =
{
AssetFileNameExtensionAttribute_t634736D44FACBB2E58C82ABE354A807BD77DEB03::get_offset_of_U3CpreferredExtensionU3Ek__BackingField_0(),
AssetFileNameExtensionAttribute_t634736D44FACBB2E58C82ABE354A807BD77DEB03::get_offset_of_U3CotherExtensionsU3Ek__BackingField_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize1699 = { sizeof (ThreadAndSerializationSafeAttribute_tC7AAA73802AAF871C176CF59656C030E5BFA87AA), -1, 0, 0 };
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"370676740@qq.com"
] | 370676740@qq.com |
663b219f61f017bb8a7f6cc4b9963301b2675a96 | 4fab02a729ca644fc093a957585bdc533954df7e | /cpp/Osmosis/Stream/Incoming.h | e25bb9c7cf5c9d1091f9d771e3eca754c892023e | [
"Apache-2.0"
] | permissive | eliran-stratoscale/osmosis | 83d17a90f4eb31e7c17abb10b79a220a73302405 | d800d924128f8d0b5f68ebe4dd7787ca8e3d69b2 | refs/heads/master | 2021-01-17T21:26:04.836017 | 2015-10-29T15:42:49 | 2015-10-29T15:42:49 | 35,344,424 | 0 | 0 | null | 2015-05-09T20:36:26 | 2015-05-09T20:36:25 | null | UTF-8 | C++ | false | false | 1,051 | h | #ifndef __OSMOSIS_STREAM_INCOMING_H__
#define __OSMOSIS_STREAM_INCOMING_H__
namespace Osmosis {
namespace Stream
{
class Incoming
{
public:
Incoming( TCPSocket & socket ) :
_socket( socket )
{
next();
}
void next()
{
struct Tongue::Chunk chunk = _socket.recieveAll< struct Tongue::Chunk >();
_bytesInBuffer = chunk.bytes;
_offset = chunk.offset;
if ( _bytesInBuffer == 0 )
return;
_socket.recieveAll( _buffer, _bytesInBuffer );
}
bool done() const
{
return _bytesInBuffer == 0;
}
size_t offset() const
{
ASSERT( ! done() );
return _offset;
}
const unsigned char * buffer() const
{
ASSERT( ! done() );
return _buffer;
}
unsigned bufferLength() const
{
ASSERT( ! done() );
return _bytesInBuffer;
}
private:
TCPSocket & _socket;
unsigned char _buffer[ 4096 ];
unsigned _bytesInBuffer;
size_t _offset;
Incoming( const Incoming & rhs ) = delete;
Incoming & operator= ( const Incoming & rhs ) = delete;
};
} // namespace Stream
} // namespace Osmosis
#endif // __OSMOSIS_STREAM_INCOMING_H__
| [
"shlomi@stratoscale.com"
] | shlomi@stratoscale.com |
2df8d65595324e08f8d938a67128c960f6bd36e4 | b6accf0ea60ee8e844f2df6bb46d97bd647730a8 | /Project/UDP_CS/udpClient.hpp | 7a962bba266aa19be6fa9d432741696f14d7dc1c | [] | no_license | Hephaestus-RC/Linux | ecd89e5d4bf2f8b2442d0faa7eda95bd8a3b254a | 7120c75643867142aa29d1a34fcebf7155d9ef16 | refs/heads/master | 2020-06-24T15:32:12.127343 | 2019-12-18T03:53:55 | 2019-12-18T03:53:55 | 199,001,833 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,294 | hpp | #pragma once
#include<iostream>
#include<string>
#include<cstring>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
using namespace std;
class Client
{
private:
int sock;
int peer_port;
string peer_ip;
public:
Client(string _ip="127.0.0.1",int _port = 8080)
:peer_ip(_ip)
,peer_port(_port)
{
sock = -1;
}
void InitClient()
{
sock = socket(AF_INET,SOCK_DGRAM,0);
if(sock<0)
{
cerr<<"socket error!"<<endl;
exit(2);
}
cout<<"Client socket success! "<<endl;
}
void Run()
{
string message;
char buf[1024];
for(;;)
{
cout<<"Please Enter #";
cin>>message;
if(message.c_str() == "exit")
return ;
struct sockaddr_in server;
server.sin_family = AF_INET;
server.sin_addr.s_addr = inet_addr(peer_ip.c_str());
server.sin_port = htons(peer_port);
socklen_t len = sizeof(server);
//client to server
sendto(sock,message.c_str(),message.size(),0,(struct sockaddr*)&server,len);
//server back-to client
ssize_t s = recvfrom(sock,buf,sizeof(buf)-1,0,(struct sockaddr*)&server,&len);
if(s > 0)
{
buf[s] = 0;
cout<<"return back:"<<buf<<endl;
}
}
}
~Client()
{
}
};
| [
"13991034472@139.com"
] | 13991034472@139.com |
a3ddede9f7e42021e6a8005b10ac8a5d10c86141 | 86ca3a23980614baf31b38d4f772fa91dc522788 | /Aula06/tabela.cpp | a9b4ebbf271927712a4739687aa002a15f6abddb | [
"MIT"
] | permissive | brayanbueno/scaling-barnacle | 20ddf6e88a92421ff0f6f3cdee37dd24b1df639a | e2f955e579dd4ae10c054760969f71df68bdffe9 | refs/heads/master | 2021-04-09T14:23:20.531372 | 2018-04-27T23:45:36 | 2018-04-27T23:45:36 | 125,578,769 | 0 | 0 | MIT | 2018-04-27T22:41:48 | 2018-03-16T23:06:52 | C++ | UTF-8 | C++ | false | false | 908 | cpp | /*
marco.mangan@pucrs.br
Aula 06
Tabela : Escreva um programa em C++ que
calcule e apresente o quadrado de
números reais entre 1 e 10, com intervalo de 0,5.
1,0 1,0
1,5 ...
2,0 4,0
2,5 ..
3,0 9,0
...
10,0 100,0
http://www.cplusplus.com/reference/ios/right/
http://www.cplusplus.com/reference/ios/fixed/
http://www.cplusplus.com/reference/iomanip/
*/
#include <iostream>
#include <iomanip>
using namespace std;
void line(int t)
{
cout << "+-";
for (int i = 1 ; i <= t ; i++)
{
cout << "-";
}
cout << "-+" << endl;
}
void box(string s)
{
int tam = s.size();
line(tam);
cout << "| " << s << " |" << endl;
line(tam);
cout << endl;
}
int main()
{
float n;
box("Exercicio 02");
for (n = 1.0f ; n <= 10.0f ; n += 0.5)
{
cout.width(6);
cout << right << fixed << setprecision(1);
cout << n;
cout.width(6);
cout << n * n << endl;
}
return 0;
}
| [
"10067320@facin.portoalegre.pucrsnet.br"
] | 10067320@facin.portoalegre.pucrsnet.br |
6c28ede92b04339b1f1c9c3fc0b1e97c9f90c04e | 49d119e4b0a264aba11582567b8b23fc0991b4c1 | /lab-07---factory-pattern-rdudh001_fzaki001_lab7-master/header/rand.hpp | 97cab3e2c317e9b3d316141a305aefdc59edf747 | [] | no_license | fadi001/fadi001-CS100_SoftwareConstruction_Labs | 2c15c475a62900f485ddf80ba73aa4d36ab76ad6 | 440fea8b05d95992adb8ab66a8118b1d7cb080f7 | refs/heads/main | 2023-06-02T13:26:34.810688 | 2021-06-19T00:22:57 | 2021-06-19T00:22:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 486 | hpp | #ifndef __RAND_HPP__
#define __RAND_HPP__
#include "iostream"
#include "base.hpp"
#include <sstream>
#include <iomanip>
#include <cstdlib>
using namespace std;
class Rand : public Base{
public:
Rand() : Base(){
srand(time(0));
randvalue = rand()%100;
}
virtual double evaluate() { return randvalue; }
virtual string stringify() {
ostringstream ss;
ss << setprecision(8) << noshowpoint << randvalue;
}
private:
double randvalue;
};
#endif //__RAND_HPP__
| [
"noreply@github.com"
] | noreply@github.com |
fb2711f576738bcea6d32d440173349370128474 | 31c92083023fe2f0e38f83d5885253e524eec10d | /tensorflow/lite/kernels/reduce.cc | 95d2370aaa8da32b4fdf9b186a809e34c9ff9156 | [
"Apache-2.0"
] | permissive | Near-Tam/tensorflow | 0c79b593e20e6012a718906aa3550e36aebb686c | 5f071f2eb2321a8e4f46f16f706e9d743ec55554 | refs/heads/master | 2020-04-28T22:54:09.727583 | 2019-03-14T13:06:05 | 2019-03-14T13:12:11 | 175,634,120 | 1 | 0 | Apache-2.0 | 2019-03-14T14:05:06 | 2019-03-14T14:05:06 | null | UTF-8 | C++ | false | false | 22,956 | cc | /* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include <string.h>
#include <limits>
#include <vector>
#include "tensorflow/lite/c/builtin_op_data.h"
#include "tensorflow/lite/c/c_api_internal.h"
#include "tensorflow/lite/kernels/gemm_support.h"
#include "tensorflow/lite/kernels/internal/optimized/optimized_ops.h"
#include "tensorflow/lite/kernels/internal/quantization_util.h"
#include "tensorflow/lite/kernels/internal/reference/reference_ops.h"
#include "tensorflow/lite/kernels/internal/tensor.h"
#include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
#include "tensorflow/lite/kernels/internal/types.h"
#include "tensorflow/lite/kernels/kernel_util.h"
#include "tensorflow/lite/kernels/op_macros.h"
namespace tflite {
namespace ops {
namespace builtin {
namespace reduce {
// This file has reference implementation of reduce_* operators.
enum KernelType {
kReference,
};
struct OpContext {
OpContext(TfLiteContext* context, TfLiteNode* node) {
params = reinterpret_cast<TfLiteReducerParams*>(node->builtin_data);
input = GetInput(context, node, 0);
axis = GetInput(context, node, 1);
output = GetOutput(context, node, 0);
}
TfLiteReducerParams* params;
const TfLiteTensor* input;
const TfLiteTensor* axis;
TfLiteTensor* output;
};
void* Init(TfLiteContext* context, const char* buffer, size_t length) {
gemm_support::IncrementUsageCounter(context);
// Creates two temp tensors to store index and axis for internal
// implementation only.
auto* scratch_tensor_index = new int;
context->AddTensors(context, 3, scratch_tensor_index);
return scratch_tensor_index;
}
void Free(TfLiteContext* context, void* buffer) {
gemm_support::DecrementUsageCounter(context);
delete reinterpret_cast<int*>(buffer);
}
// Resizes the temp tensor that stores resolved axis.
TfLiteStatus ResizeTempAxis(TfLiteContext* context, OpContext* op_context,
TfLiteTensor* resolved_axis) {
TfLiteIntArray* axis_size = TfLiteIntArrayCreate(1);
axis_size->data[0] = static_cast<int>(NumElements(op_context->axis));
return context->ResizeTensor(context, resolved_axis, axis_size);
}
// Resizes the temp tensor that stores temp sum of reduced elements.
TfLiteStatus ResizeTempSum(TfLiteContext* context, OpContext* op_context,
TfLiteTensor* temp_sum) {
TfLiteIntArray* size = TfLiteIntArrayCreate(1);
size->data[0] = static_cast<int>(NumElements(op_context->output));
return context->ResizeTensor(context, temp_sum, size);
}
// Resizes output array based on the input size and resolved axis.
TfLiteStatus ResizeOutputTensor(TfLiteContext* context, OpContext* op_context) {
size_t num_axis = NumElements(op_context->axis);
const TfLiteIntArray* input_dims = op_context->input->dims;
int input_num_dims = NumDimensions(op_context->input);
if (input_num_dims == 0) {
return context->ResizeTensor(context, op_context->output,
TfLiteIntArrayCreate(0));
}
const int* axis = GetTensorData<int>(op_context->axis);
if (op_context->params->keep_dims) {
TfLiteIntArray* output_dims = TfLiteIntArrayCreate(input_num_dims);
for (int idx = 0; idx < input_num_dims; ++idx) {
bool is_axis = false;
for (int axis_idx = 0; axis_idx < num_axis; ++axis_idx) {
if (axis[axis_idx] == idx || axis[axis_idx] + input_num_dims == idx) {
is_axis = true;
break;
}
}
if (is_axis) {
output_dims->data[idx] = 1;
} else {
output_dims->data[idx] = input_dims->data[idx];
}
}
return context->ResizeTensor(context, op_context->output, output_dims);
} else {
// Calculates size of reducing axis.
int num_reduce_axis = num_axis;
for (int i = 0; i < num_axis; ++i) {
int current = axis[i];
if (current < 0) {
current += input_num_dims;
}
TF_LITE_ENSURE(context, current >= 0 && current < input_num_dims);
for (int j = 0; j < i; ++j) {
int previous = axis[j];
if (previous < 0) {
previous += input_num_dims;
}
if (current == previous) {
--num_reduce_axis;
break;
}
}
}
// Determines output dimensions.
TfLiteIntArray* output_dims =
TfLiteIntArrayCreate(input_num_dims - num_reduce_axis);
int num_skip_axis = 0;
for (int idx = 0; idx < input_num_dims; ++idx) {
bool is_axis = false;
for (int axis_idx = 0; axis_idx < num_axis; ++axis_idx) {
if (axis[axis_idx] == idx || axis[axis_idx] + input_num_dims == idx) {
++num_skip_axis;
is_axis = true;
break;
}
}
if (!is_axis) {
output_dims->data[idx - num_skip_axis] = input_dims->data[idx];
}
}
return context->ResizeTensor(context, op_context->output, output_dims);
}
}
// Initializes temp tensors to store index and resolved axis.
TfLiteStatus InitializeTemporaries(TfLiteContext* context, TfLiteNode* node,
OpContext* op_context) {
// Creates a temp index to iterate through input data.
int* scratch_tensor_index = reinterpret_cast<int*>(node->user_data);
TfLiteIntArrayFree(node->temporaries);
node->temporaries = TfLiteIntArrayCreate(3);
node->temporaries->data[0] = *scratch_tensor_index;
TfLiteTensor* scratch_tensor = GetTemporary(context, node, /*index=*/0);
scratch_tensor->type = kTfLiteInt32;
scratch_tensor->allocation_type = kTfLiteArenaRw;
TfLiteIntArray* index_size = TfLiteIntArrayCreate(1);
index_size->data[0] = NumDimensions(op_context->input);
TF_LITE_ENSURE_OK(context,
context->ResizeTensor(context, scratch_tensor, index_size));
// Creates a temp tensor to store resolved axis given input data.
node->temporaries->data[1] = *scratch_tensor_index + 1;
TfLiteTensor* resolved_axis = GetTemporary(context, node, /*index=*/1);
resolved_axis->type = kTfLiteInt32;
// Creates a temp tensor to store temp sums when calculating mean.
node->temporaries->data[2] = *scratch_tensor_index + 2;
TfLiteTensor* temp_sum = GetTemporary(context, node, /*index=*/2);
switch (op_context->input->type) {
case kTfLiteFloat32:
temp_sum->type = kTfLiteFloat32;
break;
case kTfLiteInt32:
temp_sum->type = kTfLiteInt64;
break;
case kTfLiteInt64:
temp_sum->type = kTfLiteInt64;
break;
case kTfLiteUInt8:
temp_sum->type = kTfLiteInt32;
break;
case kTfLiteInt8:
temp_sum->type = kTfLiteInt32;
break;
case kTfLiteBool:
temp_sum->type = kTfLiteBool;
break;
default:
return kTfLiteError;
}
return kTfLiteOk;
}
TfLiteStatus PrepareSimple(TfLiteContext* context, TfLiteNode* node) {
TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
OpContext op_context(context, node);
TF_LITE_ENSURE_OK(context, InitializeTemporaries(context, node, &op_context));
TfLiteTensor* resolved_axis = GetTemporary(context, node, /*index=*/1);
// Leaves work to Eval if axis is not constant; else resizes output.
if (!IsConstantTensor(op_context.axis)) {
SetTensorToDynamic(op_context.output);
SetTensorToDynamic(resolved_axis);
return kTfLiteOk;
}
resolved_axis->allocation_type = kTfLiteArenaRw;
TF_LITE_ENSURE_OK(context,
ResizeTempAxis(context, &op_context, resolved_axis));
TF_LITE_ENSURE_OK(context, ResizeOutputTensor(context, &op_context));
return kTfLiteOk;
}
TfLiteStatus PrepareAny(TfLiteContext* context, TfLiteNode* node) {
TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
const TfLiteTensor* input = GetInput(context, node, 0);
TF_LITE_ENSURE_EQ(context, input->type, kTfLiteBool);
return PrepareSimple(context, node);
}
TfLiteStatus PrepareMeanOrSum(TfLiteContext* context, TfLiteNode* node) {
TF_LITE_ENSURE_OK(context, PrepareSimple(context, node));
// reduce_mean requires a buffer to store intermediate sum result.
OpContext op_context(context, node);
TfLiteTensor* temp_sum = GetTemporary(context, node, /*index=*/2);
if (!IsConstantTensor(op_context.axis)) {
SetTensorToDynamic(temp_sum);
return kTfLiteOk;
}
temp_sum->allocation_type = kTfLiteArenaRw;
return ResizeTempSum(context, &op_context, temp_sum);
}
void ResolveAxis(const int* axis_data, int axis_count,
tflite::MeanParams* op_params) {
int i = 0;
for (; i < axis_count; ++i) {
op_params->axis[i] = static_cast<int16>(axis_data[i]);
}
for (; i < 4; ++i) {
op_params->axis[i] = 1;
}
}
template <KernelType kernel_type>
TfLiteStatus EvalMean(TfLiteContext* context, TfLiteNode* node) {
OpContext op_context(context, node);
int num_axis = static_cast<int>(NumElements(op_context.axis));
TfLiteTensor* temp_index = GetTemporary(context, node, /*index=*/0);
TfLiteTensor* resolved_axis = GetTemporary(context, node, /*index=*/1);
TfLiteTensor* temp_sum = GetTemporary(context, node, /*index=*/2);
// Resize the output tensor if the output tensor is dynamic.
if (IsDynamicTensor(op_context.output)) {
TF_LITE_ENSURE_OK(context,
ResizeTempAxis(context, &op_context, resolved_axis));
TF_LITE_ENSURE_OK(context, ResizeOutputTensor(context, &op_context));
TF_LITE_ENSURE_OK(context, ResizeTempSum(context, &op_context, temp_sum));
}
// Defer to specialized implementation for 4D Mean across axes 1 & 2.
if (op_context.input->type == kTfLiteFloat32 ||
op_context.input->type == kTfLiteUInt8) {
tflite::MeanParams op_params;
op_params.axis_count = num_axis;
ResolveAxis(GetTensorData<int>(op_context.axis), num_axis, &op_params);
const TfLiteTensor* input = op_context.input;
if (op_context.params->keep_dims && NumDimensions(input) == 4 &&
op_params.axis_count == 2 &&
((op_params.axis[0] == 1 && op_params.axis[1] == 2) ||
(op_params.axis[0] == 2 && op_params.axis[1] == 1))) {
if (op_context.input->type == kTfLiteUInt8) {
gemmlowp::GemmContext* gemm_context =
gemm_support::GetFromContext(context);
optimized_ops::Mean(
op_params, GetTensorShape(input), GetTensorData<uint8_t>(input),
op_context.input->params.zero_point, op_context.input->params.scale,
GetTensorShape(op_context.output),
GetTensorData<uint8_t>(op_context.output),
op_context.output->params.zero_point,
op_context.output->params.scale, gemm_context);
} else {
reference_ops::Mean(op_params, GetTensorShape(input),
GetTensorData<float>(input),
GetTensorShape(op_context.output),
GetTensorData<float>(op_context.output));
}
return kTfLiteOk;
}
}
#define TF_LITE_MEAN(kernel_type, data_type, temp_data_type) \
kernel_type::Mean<>( \
GetTensorData<data_type>(op_context.input), \
op_context.input->dims->data, op_context.input->dims->size, \
GetTensorData<data_type>(op_context.output), \
op_context.output->dims->data, op_context.output->dims->size, \
GetTensorData<int>(op_context.axis), num_axis, \
op_context.params->keep_dims, GetTensorData<int>(temp_index), \
GetTensorData<int>(resolved_axis), \
GetTensorData<temp_data_type>(temp_sum))
if (kernel_type == kReference) {
switch (op_context.input->type) {
case kTfLiteFloat32: {
tflite::MeanParams op_params;
op_params.axis_count = num_axis;
ResolveAxis(GetTensorData<int>(op_context.axis), num_axis, &op_params);
const TfLiteTensor* input = op_context.input;
if (op_context.params->keep_dims && NumDimensions(input) == 4 &&
op_params.axis_count == 2 &&
((op_params.axis[0] == 1 && op_params.axis[1] == 2) ||
(op_params.axis[0] == 2 && op_params.axis[1] == 1))) {
reference_ops::Mean(op_params, GetTensorShape(input),
GetTensorData<float>(input),
GetTensorShape(op_context.output),
GetTensorData<float>(op_context.output));
} else {
TF_LITE_ENSURE(context, TF_LITE_MEAN(reference_ops, float, float));
}
} break;
case kTfLiteInt32:
TF_LITE_ENSURE(context, TF_LITE_MEAN(reference_ops, int, int64_t));
break;
case kTfLiteInt64:
TF_LITE_ENSURE(context, TF_LITE_MEAN(reference_ops, int64_t, int64_t));
break;
case kTfLiteUInt8:
if (op_context.input->params.zero_point ==
op_context.output->params.zero_point &&
op_context.input->params.scale == op_context.output->params.scale) {
TF_LITE_ENSURE(context, TF_LITE_MEAN(reference_ops, uint8_t, int));
} else {
TF_LITE_ENSURE(
context,
reference_ops::QuantizedMeanOrSum<>(
GetTensorData<uint8_t>(op_context.input),
op_context.input->params.zero_point,
op_context.input->params.scale, op_context.input->dims->data,
op_context.input->dims->size,
GetTensorData<uint8_t>(op_context.output),
op_context.output->params.zero_point,
op_context.output->params.scale,
op_context.output->dims->data, op_context.output->dims->size,
GetTensorData<int>(op_context.axis), num_axis,
op_context.params->keep_dims, GetTensorData<int>(temp_index),
GetTensorData<int>(resolved_axis),
GetTensorData<int>(temp_sum),
/*compute_sum=*/false));
}
break;
default:
return kTfLiteError;
}
}
#undef TF_LITE_MEAN
return kTfLiteOk;
}
// The underlying logic for Reduce Sum/Prod/Max/Min/Any
template <typename T>
TfLiteStatus EvalLogic(TfLiteContext* context, TfLiteNode* node,
OpContext* op_context, T init_value,
T reducer(const T current, const T in)) {
int64_t num_axis = NumElements(op_context->axis);
TfLiteTensor* temp_index = GetTemporary(context, node, /*index=*/0);
TfLiteTensor* resolved_axis = GetTemporary(context, node, /*index=*/1);
// Resize the output tensor if the output tensor is dynamic.
if (IsDynamicTensor(op_context->output)) {
TF_LITE_ENSURE_OK(context,
ResizeTempAxis(context, op_context, resolved_axis));
TF_LITE_ENSURE_OK(context, ResizeOutputTensor(context, op_context));
}
if (op_context->input->type == kTfLiteUInt8) {
TF_LITE_ENSURE_EQ(context, op_context->input->params.scale,
op_context->output->params.scale);
TF_LITE_ENSURE_EQ(context, op_context->input->params.zero_point,
op_context->output->params.zero_point);
}
TF_LITE_ENSURE(
context,
reference_ops::ReduceGeneric<T>(
GetTensorData<T>(op_context->input), op_context->input->dims->data,
op_context->input->dims->size, GetTensorData<T>(op_context->output),
op_context->output->dims->data, op_context->output->dims->size,
GetTensorData<int>(op_context->axis), num_axis,
op_context->params->keep_dims, GetTensorData<int>(temp_index),
GetTensorData<int>(resolved_axis), init_value, reducer));
return kTfLiteOk;
}
enum ReduceType {
kSum,
kProd,
kMax,
kMin,
kAny,
};
// Eval for determined input type and reduce type.
template <typename T>
TfLiteStatus EvalType(TfLiteContext* context, TfLiteNode* node,
OpContext* op_context, ReduceType reduce_type) {
switch (reduce_type) {
case kSum:
return EvalLogic<T>(
context, node, op_context, static_cast<T>(0),
[](const T current, const T in) -> T { return in + current; });
break;
case kProd:
return EvalLogic<T>(
context, node, op_context, static_cast<T>(1),
[](const T current, const T in) -> T { return in * current; });
break;
case kMax:
return EvalLogic<T>(context, node, op_context,
std::numeric_limits<T>::lowest(),
[](const T current, const T in) -> T {
return (in > current) ? in : current;
});
break;
case kMin:
return EvalLogic<T>(context, node, op_context,
std::numeric_limits<T>::max(),
[](const T current, const T in) -> T {
return (in < current) ? in : current;
});
break;
default:
return kTfLiteError;
}
}
// Template specialization for bool type
template <>
TfLiteStatus EvalType<bool>(TfLiteContext* context, TfLiteNode* node,
OpContext* op_context, ReduceType reduce_type) {
switch (reduce_type) {
case kAny:
return EvalLogic<bool>(context, node, op_context, false,
[](const bool current, const bool in) -> bool {
return in || current;
});
break;
default:
return kTfLiteError;
}
}
// The entry point that handles input types and then calls template functions to
// handle ReduceType.
template <KernelType kernel_type, ReduceType reduce_type>
TfLiteStatus EvalGeneric(TfLiteContext* context, TfLiteNode* node) {
if (kernel_type != kReference) {
return kTfLiteOk;
}
OpContext op_context(context, node);
switch (op_context.input->type) {
case kTfLiteFloat32:
return EvalType<float>(context, node, &op_context, reduce_type);
break;
case kTfLiteInt32:
return EvalType<int>(context, node, &op_context, reduce_type);
break;
case kTfLiteInt64:
return EvalType<int64_t>(context, node, &op_context, reduce_type);
break;
case kTfLiteUInt8:
return EvalType<uint8_t>(context, node, &op_context, reduce_type);
break;
case kTfLiteInt8:
return EvalType<int8_t>(context, node, &op_context, reduce_type);
break;
case kTfLiteBool:
return EvalType<bool>(context, node, &op_context, reduce_type);
break;
default:
return kTfLiteError;
}
}
TfLiteStatus EvalSum(TfLiteContext* context, TfLiteNode* node) {
OpContext op_context(context, node);
const auto& input = op_context.input;
const auto& output = op_context.output;
if (input->type != kTfLiteUInt8 ||
(input->params.scale == output->params.scale &&
input->params.zero_point == output->params.zero_point)) {
return EvalGeneric<kReference, kSum>(context, node);
} else {
// Rescaling 8bit reduce sum.
int num_axis = static_cast<int>(NumElements(op_context.axis));
TfLiteTensor* temp_index = GetTemporary(context, node, /*index=*/0);
TfLiteTensor* resolved_axis = GetTemporary(context, node, /*index=*/1);
TfLiteTensor* temp_sum = GetTemporary(context, node, /*index=*/2);
// Resize the output tensor if the output tensor is dynamic.
if (IsDynamicTensor(op_context.output)) {
TF_LITE_ENSURE_OK(context,
ResizeTempAxis(context, &op_context, resolved_axis));
TF_LITE_ENSURE_OK(context, ResizeOutputTensor(context, &op_context));
TF_LITE_ENSURE_OK(context, ResizeTempSum(context, &op_context, temp_sum));
}
TF_LITE_ENSURE(
context,
reference_ops::QuantizedMeanOrSum<>(
GetTensorData<uint8_t>(op_context.input),
op_context.input->params.zero_point, op_context.input->params.scale,
op_context.input->dims->data, op_context.input->dims->size,
GetTensorData<uint8_t>(op_context.output),
op_context.output->params.zero_point,
op_context.output->params.scale, op_context.output->dims->data,
op_context.output->dims->size, GetTensorData<int>(op_context.axis),
num_axis, op_context.params->keep_dims,
GetTensorData<int>(temp_index), GetTensorData<int>(resolved_axis),
GetTensorData<int32>(temp_sum), /*compute_sum=*/true));
}
return kTfLiteOk;
}
} // namespace reduce
TfLiteRegistration* Register_MEAN_REF() {
static TfLiteRegistration r = {reduce::Init, reduce::Free,
reduce::PrepareMeanOrSum,
reduce::EvalMean<reduce::kReference>};
return &r;
}
TfLiteRegistration* Register_SUM_REF() {
static TfLiteRegistration r = {reduce::Init, reduce::Free,
reduce::PrepareMeanOrSum, reduce::EvalSum};
return &r;
}
TfLiteRegistration* Register_REDUCE_PROD_REF() {
static TfLiteRegistration r = {
reduce::Init, reduce::Free, reduce::PrepareSimple,
reduce::EvalGeneric<reduce::kReference, reduce::kProd>};
return &r;
}
TfLiteRegistration* Register_REDUCE_MAX_REF() {
static TfLiteRegistration r = {
reduce::Init, reduce::Free, reduce::PrepareSimple,
reduce::EvalGeneric<reduce::kReference, reduce::kMax>};
return &r;
}
TfLiteRegistration* Register_REDUCE_MIN_REF() {
static TfLiteRegistration r = {
reduce::Init, reduce::Free, reduce::PrepareSimple,
reduce::EvalGeneric<reduce::kReference, reduce::kMin>};
return &r;
}
TfLiteRegistration* Register_REDUCE_ANY_REF() {
static TfLiteRegistration r = {
reduce::Init, reduce::Free, reduce::PrepareAny,
reduce::EvalGeneric<reduce::kReference, reduce::kAny>};
return &r;
}
// TODO(kanlig): add optimized implementation of Mean.
TfLiteRegistration* Register_MEAN() { return Register_MEAN_REF(); }
TfLiteRegistration* Register_SUM() { return Register_SUM_REF(); }
TfLiteRegistration* Register_REDUCE_PROD() {
return Register_REDUCE_PROD_REF();
}
TfLiteRegistration* Register_REDUCE_MAX() { return Register_REDUCE_MAX_REF(); }
TfLiteRegistration* Register_REDUCE_MIN() { return Register_REDUCE_MIN_REF(); }
TfLiteRegistration* Register_REDUCE_ANY() { return Register_REDUCE_ANY_REF(); }
} // namespace builtin
} // namespace ops
} // namespace tflite
| [
"gardener@tensorflow.org"
] | gardener@tensorflow.org |
40cac72dbffc1cd605bdc1a349cd2d07d86bc619 | ef5787f7594d819b7f86b3ffbaf753f60b8ba18e | /src/memcheck.cpp | 8f78dabb4f0a32791bdba93f93f1070c280fb744 | [] | no_license | trebla64/blood | 56d8ad5435768d021bb980c97fb00cfe154ba9b2 | 7d5cde7d86d0d4ef08d6340cc6b35c653bfb79d6 | refs/heads/main | 2023-07-01T03:36:37.495755 | 2021-08-05T16:08:07 | 2021-08-05T16:08:07 | 393,092,013 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,147 | cpp | #include "stdafx.h"
#include "debug4g.h"
#include "error.h"
#ifdef ENABLE_MEMORY_LEAK_DETECTION
# undef malloc
# undef free
#endif
struct AllocationNode
{
AllocationNode *prev;
AllocationNode *next;
void *pMemory;
unsigned nSize;
const char *pzFunction;
const char *pzFile;
unsigned nLine;
};
static AllocationNode *head_alloc = NULL;
static AllocationNode *tail_alloc = NULL;
void *malloc_tracked(unsigned size, const char *pzFunction, const char *pzFile, unsigned nLine)
{
void *pMem = malloc(size);
if (pMem == NULL)
ThrowError("Failed allocating managed memory");
// Alloc node
AllocationNode *pNode = (AllocationNode *)malloc(sizeof(AllocationNode));
if (pNode == NULL)
ThrowError("Failed allocating allocation node in managed memory");
memset(pNode, 0, sizeof(AllocationNode));
if (!head_alloc)
{
head_alloc = tail_alloc = pNode;
}
else
{
pNode->prev = tail_alloc;
tail_alloc->next = pNode;
tail_alloc = pNode;
}
pNode->pMemory = pMem;
pNode->nSize = size;
pNode->pzFunction = pzFunction;
pNode->pzFile = pzFile;
pNode->nLine = nLine;
return pMem;
}
void free_tracked(void *pBuffer, const char *pzFunction, const char *pzFile, unsigned nLine)
{
AllocationNode *pNode, *pNode_next;
bool found = false;
for (pNode = head_alloc; pNode; pNode = pNode_next)
{
pNode_next = pNode->next;
if (pBuffer == pNode->pMemory)
{
// Found it
if (pNode->prev)
pNode->prev->next = pNode->next;
if (pNode->next)
pNode->next->prev = pNode->prev;
found = true;
break;
}
}
if (!found)
ThrowError("Attempting to free memory in file %s, line %u that was never allocated", pzFile, nLine);
free(pBuffer);
}
void DumpLeaks()
{
FILE *fout = fopen("leaks.txt", "wt");
if (!fout) return;
unsigned nTotalLeaked = 0;
for (AllocationNode *pNode = head_alloc; pNode; pNode = pNode->next)
{
fprintf(fout, "%p %10u %15s %15s %5u\n", pNode->pMemory, pNode->nSize, pNode->pzFunction, pNode->pzFile, pNode->nLine);
nTotalLeaked += pNode->nSize;
}
fprintf(fout, "\nLeaked a total of %u bytes\n", nTotalLeaked);
fflush(fout);
fclose(fout);
}
| [
"albert.minnie@gmail.com"
] | albert.minnie@gmail.com |
50a5c551678f2945dc57ac878eaa2d26b662ce41 | 1ee90596d52554cb4ef51883c79093897f5279a0 | /Sisteme/[C++]Offine Shop - Ken/Source Files/Client/Userinterface/PythonNetworkStream.cpp | 577170dea3c961b01c93af052dd3a2d94a908911 | [] | no_license | Reizonr1/metin2-adv | bf7ecb26352b13641cd69b982a48a6b20061979a | 5c2c096015ef3971a2f1121b54e33358d973c694 | refs/heads/master | 2022-04-05T20:50:38.176241 | 2020-03-03T18:20:58 | 2020-03-03T18:20:58 | 233,462,795 | 1 | 1 | null | null | null | null | UHC | C++ | false | false | 30,931 | cpp | #include "StdAfx.h"
#include "../eterLib/NetPacketHeaderMap.h"
#include "PythonNetworkStream.h"
#include "Packet.h"
#include "NetworkActorManager.h"
#include "GuildMarkDownloader.h"
#include "GuildMarkUploader.h"
#include "MarkManager.h"
#include "ProcessCRC.h"
// MARK_BUG_FIX
static DWORD gs_nextDownloadMarkTime = 0;
// END_OF_MARK_BUG_FIX
// Packet ---------------------------------------------------------------------------
class CMainPacketHeaderMap : public CNetworkPacketHeaderMap
{
public:
enum
{
STATIC_SIZE_PACKET = false,
DYNAMIC_SIZE_PACKET = true,
};
public:
CMainPacketHeaderMap()
{
Set(HEADER_GC_EMPIRE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCEmpire), STATIC_SIZE_PACKET));
Set(HEADER_GC_WARP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCWarp), STATIC_SIZE_PACKET));
Set(HEADER_GC_SKILL_COOLTIME_END, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSkillCoolTimeEnd), STATIC_SIZE_PACKET));
Set(HEADER_GC_QUEST_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuestInfo), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_REQUEST_MAKE_GUILD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
Set(HEADER_GC_PVP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPVP), STATIC_SIZE_PACKET));
Set(HEADER_GC_DUEL_START, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDuelStart), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterAdd), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHAR_ADDITIONAL_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterAdditionalInfo), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_ADD2, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterAdd2), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterUpdate), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_UPDATE2, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterUpdate2), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterDelete), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_MOVE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMove), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHAT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChat), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_SYNC_POSITION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCC2C), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_LOGIN_SUCCESS3, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginSuccess3), STATIC_SIZE_PACKET));
Set(HEADER_GC_LOGIN_SUCCESS4, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginSuccess4), STATIC_SIZE_PACKET));
Set(HEADER_GC_LOGIN_FAILURE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginFailure), STATIC_SIZE_PACKET));
Set(HEADER_GC_PLAYER_CREATE_SUCCESS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPlayerCreateSuccess), STATIC_SIZE_PACKET));
Set(HEADER_GC_PLAYER_CREATE_FAILURE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCreateFailure), STATIC_SIZE_PACKET));
Set(HEADER_GC_PLAYER_DELETE_SUCCESS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
Set(HEADER_GC_PLAYER_DELETE_WRONG_SOCIAL_ID, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
Set(HEADER_GC_STUN, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCStun), STATIC_SIZE_PACKET));
Set(HEADER_GC_DEAD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDead), STATIC_SIZE_PACKET));
Set(HEADER_GC_MAIN_CHARACTER, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter), STATIC_SIZE_PACKET));
// SUPPORT_BGM
Set(HEADER_GC_MAIN_CHARACTER2_EMPIRE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter2_EMPIRE), STATIC_SIZE_PACKET));
Set(HEADER_GC_MAIN_CHARACTER3_BGM, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter3_BGM), STATIC_SIZE_PACKET));
Set(HEADER_GC_MAIN_CHARACTER4_BGM_VOL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter4_BGM_VOL), STATIC_SIZE_PACKET));
// END_OFSUPPORT_BGM
Set(HEADER_GC_PLAYER_POINTS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPoints), STATIC_SIZE_PACKET));
Set(HEADER_GC_PLAYER_POINT_CHANGE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPointChange), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_SET, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_SET2, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet2), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_USE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemUse), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemUpdate), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_GROUND_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemGroundAdd), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_GROUND_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemGroundDel), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_OWNERSHIP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemOwnership), STATIC_SIZE_PACKET));
Set(HEADER_GC_QUICKSLOT_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuickSlotAdd), STATIC_SIZE_PACKET));
Set(HEADER_GC_QUICKSLOT_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuickSlotDel), STATIC_SIZE_PACKET));
Set(HEADER_GC_QUICKSLOT_SWAP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuickSlotSwap), STATIC_SIZE_PACKET));
Set(HEADER_GC_WHISPER, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCWhisper), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_POSITION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPosition), STATIC_SIZE_PACKET));
Set(HEADER_GC_MOTION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMotion), STATIC_SIZE_PACKET));
Set(HEADER_GC_SHOP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCShop), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_SHOP_SIGN, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCShopSign), STATIC_SIZE_PACKET));
Set(HEADER_GC_EXCHANGE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCExchange), STATIC_SIZE_PACKET));
Set(HEADER_GC_PING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPing), STATIC_SIZE_PACKET));
Set(HEADER_GC_SCRIPT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCScript), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_QUEST_CONFIRM, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuestConfirm), STATIC_SIZE_PACKET));
Set(HEADER_GC_TARGET, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTarget), STATIC_SIZE_PACKET));
Set(HEADER_GC_MOUNT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMount), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHANGE_SPEED, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChangeSpeed), STATIC_SIZE_PACKET));
Set(HEADER_GC_HANDSHAKE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHandshake), STATIC_SIZE_PACKET));
Set(HEADER_GC_HANDSHAKE_OK, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
Set(HEADER_GC_BINDUDP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBindUDP), STATIC_SIZE_PACKET));
Set(HEADER_GC_OWNERSHIP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCOwnership), STATIC_SIZE_PACKET));
Set(HEADER_GC_CREATE_FLY, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCreateFly), STATIC_SIZE_PACKET));
#ifdef _IMPROVED_PACKET_ENCRYPTION_
Set(HEADER_GC_KEY_AGREEMENT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketKeyAgreement), STATIC_SIZE_PACKET));
Set(HEADER_GC_KEY_AGREEMENT_COMPLETED, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketKeyAgreementCompleted), STATIC_SIZE_PACKET));
#endif
Set(HEADER_GC_ADD_FLY_TARGETING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFlyTargeting), STATIC_SIZE_PACKET));
Set(HEADER_GC_FLY_TARGETING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFlyTargeting), STATIC_SIZE_PACKET));
Set(HEADER_GC_PHASE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPhase), STATIC_SIZE_PACKET));
Set(HEADER_GC_SKILL_LEVEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSkillLevel), STATIC_SIZE_PACKET));
Set(HEADER_GC_SKILL_LEVEL_NEW, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSkillLevelNew), STATIC_SIZE_PACKET));
Set(HEADER_GC_MESSENGER, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMessenger), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_GUILD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCGuild), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_INVITE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyInvite), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyAdd), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyUpdate), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_REMOVE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyRemove), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_LINK, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyLink), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_UNLINK, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyUnlink), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_PARAMETER, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyParameter), STATIC_SIZE_PACKET));
Set(HEADER_GC_SAFEBOX_SET, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet), STATIC_SIZE_PACKET));
Set(HEADER_GC_SAFEBOX_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemDel), STATIC_SIZE_PACKET));
Set(HEADER_GC_SAFEBOX_WRONG_PASSWORD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSafeboxWrongPassword), STATIC_SIZE_PACKET));
Set(HEADER_GC_SAFEBOX_SIZE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSafeboxSize), STATIC_SIZE_PACKET));
Set(HEADER_GC_SAFEBOX_MONEY_CHANGE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSafeboxMoneyChange), STATIC_SIZE_PACKET));
Set(HEADER_GC_FISHING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFishing), STATIC_SIZE_PACKET));
Set(HEADER_GC_DUNGEON, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDungeon), DYNAMIC_SIZE_PACKET));
//Set(HEADER_GC_SLOW_TIMER, CNetworkPacketHeaderMap::TPacketType(sizeof(BYTE), STATIC_SIZE_PACKET));
Set(HEADER_GC_TIME, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTime), STATIC_SIZE_PACKET));
Set(HEADER_GC_WALK_MODE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCWalkMode), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHANGE_SKILL_GROUP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChangeSkillGroup), STATIC_SIZE_PACKET));
Set(HEADER_GC_REFINE_INFORMATION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCRefineInformation), STATIC_SIZE_PACKET));
Set(HEADER_GC_REFINE_INFORMATION_NEW, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCRefineInformationNew), STATIC_SIZE_PACKET));
Set(HEADER_GC_SEPCIAL_EFFECT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSpecialEffect), STATIC_SIZE_PACKET));
Set(HEADER_GC_NPC_POSITION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCNPCPosition), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_CHANGE_NAME, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChangeName), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHINA_MATRIX_CARD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChinaMatrixCard), STATIC_SIZE_PACKET));
Set(HEADER_GC_RUNUP_MATRIX_QUIZ, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCRunupMatrixQuiz), STATIC_SIZE_PACKET));
Set(HEADER_GC_NEWCIBN_PASSPOD_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCNEWCIBNPasspodRequest), STATIC_SIZE_PACKET));
Set(HEADER_GC_NEWCIBN_PASSPOD_FAILURE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCNEWCIBNPasspodFailure), STATIC_SIZE_PACKET));
Set(HEADER_GC_LOGIN_KEY, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginKey), STATIC_SIZE_PACKET));
Set(HEADER_GC_AUTH_SUCCESS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAuthSuccess), STATIC_SIZE_PACKET));
Set(HEADER_GC_AUTH_SUCCESS_OPENID, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAuthSuccessOpenID), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHANNEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChannel), STATIC_SIZE_PACKET));
Set(HEADER_GC_VIEW_EQUIP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCViewEquip), STATIC_SIZE_PACKET));
Set(HEADER_GC_LAND_LIST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLandList), DYNAMIC_SIZE_PACKET));
//Set(HEADER_GC_TARGET_CREATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetCreate), STATIC_SIZE_PACKET));
Set(HEADER_GC_TARGET_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetUpdate), STATIC_SIZE_PACKET));
Set(HEADER_GC_TARGET_DELETE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetDelete), STATIC_SIZE_PACKET));
Set(HEADER_GC_TARGET_CREATE_NEW, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetCreateNew), STATIC_SIZE_PACKET));
Set(HEADER_GC_AFFECT_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAffectAdd), STATIC_SIZE_PACKET));
Set(HEADER_GC_AFFECT_REMOVE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAffectRemove), STATIC_SIZE_PACKET));
Set(HEADER_GC_MALL_OPEN, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMallOpen), STATIC_SIZE_PACKET));
Set(HEADER_GC_MALL_SET, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet), STATIC_SIZE_PACKET));
Set(HEADER_GC_MALL_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemDel), STATIC_SIZE_PACKET));
Set(HEADER_GC_LOVER_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoverInfo), STATIC_SIZE_PACKET));
Set(HEADER_GC_LOVE_POINT_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLovePointUpdate), STATIC_SIZE_PACKET));
Set(HEADER_GC_DIG_MOTION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDigMotion), STATIC_SIZE_PACKET));
Set(HEADER_GC_DAMAGE_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDamageInfo), STATIC_SIZE_PACKET));
Set(HEADER_GC_HS_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketHSCheck), STATIC_SIZE_PACKET));
Set(HEADER_GC_XTRAP_CS1_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketXTrapCSVerify), STATIC_SIZE_PACKET));
Set(HEADER_GC_HYBRIDCRYPT_KEYS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHybridCryptKeys), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_HYBRIDCRYPT_SDB, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHybridSDB), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_SPECIFIC_EFFECT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSpecificEffect), STATIC_SIZE_PACKET));
Set(HEADER_GC_DRAGON_SOUL_REFINE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDragonSoulRefine), STATIC_SIZE_PACKET));
#ifdef ENABLE_OFFLINE_SHOP_SYSTEM
Set(HEADER_GC_OFFLINE_SHOP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCShop), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_OFFLINE_SHOP_SIGN, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCShopSign), STATIC_SIZE_PACKET));
#endif
}
};
int g_iLastPacket[2] = { 0, 0 };
void CPythonNetworkStream::ExitApplication()
{
if (__IsNotPing())
{
AbsoluteExitApplication();
}
else
{
SendChatPacket("/quit");
}
}
void CPythonNetworkStream::ExitGame()
{
if (__IsNotPing())
{
LogOutGame();
}
else
{
SendChatPacket("/phase_select");
}
}
void CPythonNetworkStream::LogOutGame()
{
if (__IsNotPing())
{
AbsoluteExitGame();
}
else
{
SendChatPacket("/logout");
}
}
void CPythonNetworkStream::AbsoluteExitGame()
{
if (!IsOnline())
return;
OnRemoteDisconnect();
Disconnect();
}
void CPythonNetworkStream::AbsoluteExitApplication()
{
PostQuitMessage(0);
}
bool CPythonNetworkStream::__IsNotPing()
{
// 원래는 핑이 안올때 체크이나 서버랑 정확히 맞추어야 한다.
return false;
}
DWORD CPythonNetworkStream::GetGuildID()
{
return m_dwGuildID;
}
UINT CPythonNetworkStream::UploadMark(const char * c_szImageFileName)
{
// MARK_BUG_FIX
// 길드를 만든 직후는 길드 아이디가 0이다.
if (0 == m_dwGuildID)
return ERROR_MARK_UPLOAD_NEED_RECONNECT;
gs_nextDownloadMarkTime = 0;
// END_OF_MARK_BUG_FIX
UINT uError=ERROR_UNKNOWN;
CGuildMarkUploader& rkGuildMarkUploader=CGuildMarkUploader::Instance();
if (!rkGuildMarkUploader.Connect(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey, m_dwGuildID, c_szImageFileName, &uError))
{
switch (uError)
{
case CGuildMarkUploader::ERROR_CONNECT:
return ERROR_CONNECT_MARK_SERVER;
break;
case CGuildMarkUploader::ERROR_LOAD:
return ERROR_LOAD_MARK;
break;
case CGuildMarkUploader::ERROR_WIDTH:
return ERROR_MARK_WIDTH;
break;
case CGuildMarkUploader::ERROR_HEIGHT:
return ERROR_MARK_HEIGHT;
break;
default:
return ERROR_UNKNOWN;
}
}
// MARK_BUG_FIX
__DownloadMark();
// END_OF_MARK_BUG_FIX
if (CGuildMarkManager::INVALID_MARK_ID == CGuildMarkManager::Instance().GetMarkID(m_dwGuildID))
return ERROR_MARK_CHECK_NEED_RECONNECT;
return ERROR_NONE;
}
UINT CPythonNetworkStream::UploadSymbol(const char* c_szImageFileName)
{
UINT uError=ERROR_UNKNOWN;
CGuildMarkUploader& rkGuildMarkUploader=CGuildMarkUploader::Instance();
if (!rkGuildMarkUploader.ConnectToSendSymbol(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey, m_dwGuildID, c_szImageFileName, &uError))
{
switch (uError)
{
case CGuildMarkUploader::ERROR_CONNECT:
return ERROR_CONNECT_MARK_SERVER;
break;
case CGuildMarkUploader::ERROR_LOAD:
return ERROR_LOAD_MARK;
break;
case CGuildMarkUploader::ERROR_WIDTH:
return ERROR_MARK_WIDTH;
break;
case CGuildMarkUploader::ERROR_HEIGHT:
return ERROR_MARK_HEIGHT;
break;
default:
return ERROR_UNKNOWN;
}
}
return ERROR_NONE;
}
void CPythonNetworkStream::__DownloadMark()
{
// 3분 안에는 다시 접속하지 않는다.
DWORD curTime = ELTimer_GetMSec();
if (curTime < gs_nextDownloadMarkTime)
return;
gs_nextDownloadMarkTime = curTime + 60000 * 3; // 3분
CGuildMarkDownloader& rkGuildMarkDownloader = CGuildMarkDownloader::Instance();
rkGuildMarkDownloader.Connect(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey);
}
void CPythonNetworkStream::__DownloadSymbol(const std::vector<DWORD> & c_rkVec_dwGuildID)
{
CGuildMarkDownloader& rkGuildMarkDownloader=CGuildMarkDownloader::Instance();
rkGuildMarkDownloader.ConnectToRecvSymbol(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey, c_rkVec_dwGuildID);
}
void CPythonNetworkStream::SetPhaseWindow(UINT ePhaseWnd, PyObject* poPhaseWnd)
{
if (ePhaseWnd>=PHASE_WINDOW_NUM)
return;
m_apoPhaseWnd[ePhaseWnd]=poPhaseWnd;
}
void CPythonNetworkStream::ClearPhaseWindow(UINT ePhaseWnd, PyObject* poPhaseWnd)
{
if (ePhaseWnd>=PHASE_WINDOW_NUM)
return;
if (poPhaseWnd != m_apoPhaseWnd[ePhaseWnd])
return;
m_apoPhaseWnd[ePhaseWnd]=0;
}
void CPythonNetworkStream::SetServerCommandParserWindow(PyObject* poWnd)
{
m_poSerCommandParserWnd = poWnd;
}
bool CPythonNetworkStream::IsSelectedEmpire()
{
if (m_dwEmpireID)
return true;
return false;
}
UINT CPythonNetworkStream::GetAccountCharacterSlotDatau(UINT iSlot, UINT eType)
{
if (iSlot >= PLAYER_PER_ACCOUNT4)
return 0;
TSimplePlayerInformation& rkSimplePlayerInfo=m_akSimplePlayerInfo[iSlot];
switch (eType)
{
case ACCOUNT_CHARACTER_SLOT_ID:
return rkSimplePlayerInfo.dwID;
case ACCOUNT_CHARACTER_SLOT_RACE:
return rkSimplePlayerInfo.byJob;
case ACCOUNT_CHARACTER_SLOT_LEVEL:
return rkSimplePlayerInfo.byLevel;
case ACCOUNT_CHARACTER_SLOT_STR:
return rkSimplePlayerInfo.byST;
case ACCOUNT_CHARACTER_SLOT_DEX:
return rkSimplePlayerInfo.byDX;
case ACCOUNT_CHARACTER_SLOT_HTH:
return rkSimplePlayerInfo.byHT;
case ACCOUNT_CHARACTER_SLOT_INT:
return rkSimplePlayerInfo.byIQ;
case ACCOUNT_CHARACTER_SLOT_PLAYTIME:
return rkSimplePlayerInfo.dwPlayMinutes;
case ACCOUNT_CHARACTER_SLOT_FORM:
// return rkSimplePlayerInfo.wParts[CRaceData::PART_MAIN];
return rkSimplePlayerInfo.wMainPart;
case ACCOUNT_CHARACTER_SLOT_PORT:
return rkSimplePlayerInfo.wPort;
case ACCOUNT_CHARACTER_SLOT_GUILD_ID:
return m_adwGuildID[iSlot];
break;
case ACCOUNT_CHARACTER_SLOT_CHANGE_NAME_FLAG:
return rkSimplePlayerInfo.bChangeName;
break;
case ACCOUNT_CHARACTER_SLOT_HAIR:
return rkSimplePlayerInfo.wHairPart;
break;
}
return 0;
}
const char* CPythonNetworkStream::GetAccountCharacterSlotDataz(UINT iSlot, UINT eType)
{
static const char* sc_szEmpty="";
if (iSlot >= PLAYER_PER_ACCOUNT4)
return sc_szEmpty;
TSimplePlayerInformation& rkSimplePlayerInfo=m_akSimplePlayerInfo[iSlot];
switch (eType)
{
case ACCOUNT_CHARACTER_SLOT_ADDR:
{
BYTE ip[4];
const int LEN = 4;
for (int i = 0; i < LEN; i++)
{
ip[i] = BYTE(rkSimplePlayerInfo.lAddr&0xff);
rkSimplePlayerInfo.lAddr>>=8;
}
static char s_szAddr[256];
sprintf(s_szAddr, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
return s_szAddr;
}
break;
case ACCOUNT_CHARACTER_SLOT_NAME:
return rkSimplePlayerInfo.szName;
break;
case ACCOUNT_CHARACTER_SLOT_GUILD_NAME:
return m_astrGuildName[iSlot].c_str();
break;
}
return sc_szEmpty;
}
void CPythonNetworkStream::ConnectLoginServer(const char* c_szAddr, UINT uPort)
{
CNetworkStream::Connect(c_szAddr, uPort);
}
void CPythonNetworkStream::SetMarkServer(const char* c_szAddr, UINT uPort)
{
m_kMarkAuth.m_kNetAddr.Set(c_szAddr, uPort);
}
void CPythonNetworkStream::ConnectGameServer(UINT iChrSlot)
{
if (iChrSlot >= PLAYER_PER_ACCOUNT4)
return;
m_dwSelectedCharacterIndex = iChrSlot;
__DirectEnterMode_Set(iChrSlot);
TSimplePlayerInformation& rkSimplePlayerInfo=m_akSimplePlayerInfo[iChrSlot];
CNetworkStream::Connect((DWORD)rkSimplePlayerInfo.lAddr, rkSimplePlayerInfo.wPort);
}
void CPythonNetworkStream::SetLoginInfo(const char* c_szID, const char* c_szPassword)
{
m_stID=c_szID;
m_stPassword=c_szPassword;
}
void CPythonNetworkStream::ClearLoginInfo( void )
{
m_stPassword = "";
}
void CPythonNetworkStream::SetLoginKey(DWORD dwLoginKey)
{
m_dwLoginKey = dwLoginKey;
}
bool CPythonNetworkStream::CheckPacket(TPacketHeader * pRetHeader)
{
*pRetHeader = 0;
static CMainPacketHeaderMap s_packetHeaderMap;
TPacketHeader header;
if (!Peek(sizeof(TPacketHeader), &header))
return false;
if (0 == header)
{
if (!Recv(sizeof(TPacketHeader), &header))
return false;
while (Peek(sizeof(TPacketHeader), &header))
{
if (0 == header)
{
if (!Recv(sizeof(TPacketHeader), &header))
return false;
}
else
{
break;
}
}
if (0 == header)
return false;
}
CNetworkPacketHeaderMap::TPacketType PacketType;
if (!s_packetHeaderMap.Get(header, &PacketType))
{
TraceError("Unknown packet header: %d, last: %d %d", header, g_iLastPacket[0], g_iLastPacket[1]);
ClearRecvBuffer();
PostQuitMessage(0);
return false;
}
// Code for dynamic size packet
if (PacketType.isDynamicSizePacket)
{
TDynamicSizePacketHeader DynamicSizePacketHeader;
if (!Peek(sizeof(TDynamicSizePacketHeader), &DynamicSizePacketHeader))
return false;
if (!Peek(DynamicSizePacketHeader.size))
{
Tracef("CPythonNetworkStream::CheckPacket - Not enough dynamic packet size: header %d packet size: %d\n",
DynamicSizePacketHeader.header,
DynamicSizePacketHeader.size);
return false;
}
}
else
{
if (!Peek(PacketType.iPacketSize))
{
//Tracef("Not enough packet size: header %d packet size: %d, recv buffer size: %d",
// header,
// PacketType.iPacketSize,
// GetRecvBufferSize());
return false;
}
}
if (!header)
return false;
*pRetHeader = header;
g_iLastPacket[0] = g_iLastPacket[1];
g_iLastPacket[1] = header;
//Tracenf("header %d size %d", header, PacketType.iPacketSize);
//Tracenf("header %d size %d outputpos[%d] security %u", header, PacketType.iPacketSize, m_recvBufOutputPos, IsSecurityMode());
return true;
}
bool CPythonNetworkStream::RecvErrorPacket(int header)
{
TraceError("Phase %s does not handle this header (header: %d, last: %d, %d)",
m_strPhase.c_str(), header, g_iLastPacket[0], g_iLastPacket[1]);
ClearRecvBuffer();
return true;
}
bool CPythonNetworkStream::RecvPhasePacket()
{
TPacketGCPhase packet_phase;
if (!Recv(sizeof(TPacketGCPhase), &packet_phase))
return false;
switch (packet_phase.phase)
{
case PHASE_CLOSE: // 끊기는 상태 (또는 끊기 전 상태)
ClosePhase();
break;
case PHASE_HANDSHAKE: // 악수..;;
SetHandShakePhase();
break;
case PHASE_LOGIN: // 로그인 중
SetLoginPhase();
break;
case PHASE_SELECT: // 캐릭터 선택 화면
SetSelectPhase();
BuildProcessCRC();
// MARK_BUG_FIX
__DownloadMark();
// END_OF_MARK_BUG_FIX
break;
case PHASE_LOADING: // 선택 후 로딩 화면
SetLoadingPhase();
break;
case PHASE_GAME: // 게임 화면
SetGamePhase();
break;
case PHASE_DEAD: // 죽었을 때.. (게임 안에 있는 것일 수도..)
break;
}
return true;
}
bool CPythonNetworkStream::RecvPingPacket()
{
Tracef("recv ping packet. (securitymode %u)\n", IsSecurityMode());
TPacketGCPing kPacketPing;
if (!Recv(sizeof(TPacketGCPing), &kPacketPing))
return false;
m_dwLastGamePingTime = ELTimer_GetMSec();
TPacketCGPong kPacketPong;
kPacketPong.bHeader = HEADER_CG_PONG;
if (!Send(sizeof(TPacketCGPong), &kPacketPong))
return false;
if (IsSecurityMode())
return SendSequence();
else
return true;
}
bool CPythonNetworkStream::RecvDefaultPacket(int header)
{
if (!header)
return true;
TraceError("처리되지 않은 패킷 헤더 %d, state %s\n", header, m_strPhase.c_str());
ClearRecvBuffer();
return true;
}
bool CPythonNetworkStream::OnProcess()
{
if (m_isStartGame)
{
m_isStartGame = FALSE;
PyCallClassMemberFunc(m_poHandler, "SetGamePhase", Py_BuildValue("()"));
// PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartGame", Py_BuildValue("()"));
}
m_rokNetActorMgr->Update();
if (m_phaseProcessFunc.IsEmpty())
return true;
//TPacketHeader header;
//while(CheckPacket(&header))
{
m_phaseProcessFunc.Run();
}
return true;
}
// Set
void CPythonNetworkStream::SetOffLinePhase()
{
if ("OffLine" != m_strPhase)
m_phaseLeaveFunc.Run();
m_strPhase = "OffLine";
Tracen("");
Tracen("## Network - OffLine Phase ##");
Tracen("");
m_dwChangingPhaseTime = ELTimer_GetMSec();
m_phaseProcessFunc.Set(this, &CPythonNetworkStream::OffLinePhase);
m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveOfflinePhase);
SetGameOffline();
m_dwSelectedCharacterIndex = 0;
__DirectEnterMode_Initialize();
__BettingGuildWar_Initialize();
}
void CPythonNetworkStream::ClosePhase()
{
PyCallClassMemberFunc(m_poHandler, "SetLoginPhase", Py_BuildValue("()"));
}
// Game Online
void CPythonNetworkStream::SetGameOnline()
{
m_isGameOnline = TRUE;
}
void CPythonNetworkStream::SetGameOffline()
{
m_isGameOnline = FALSE;
}
BOOL CPythonNetworkStream::IsGameOnline()
{
return m_isGameOnline;
}
// Handler
void CPythonNetworkStream::SetHandler(PyObject* poHandler)
{
m_poHandler = poHandler;
}
// ETC
DWORD CPythonNetworkStream::GetMainActorVID()
{
return m_dwMainActorVID;
}
DWORD CPythonNetworkStream::GetMainActorRace()
{
return m_dwMainActorRace;
}
DWORD CPythonNetworkStream::GetMainActorEmpire()
{
return m_dwMainActorEmpire;
}
DWORD CPythonNetworkStream::GetMainActorSkillGroup()
{
return m_dwMainActorSkillGroup;
}
void CPythonNetworkStream::SetEmpireID(DWORD dwEmpireID)
{
m_dwEmpireID = dwEmpireID;
}
DWORD CPythonNetworkStream::GetEmpireID()
{
return m_dwEmpireID;
}
void CPythonNetworkStream::__ClearSelectCharacterData()
{
NANOBEGIN
memset(&m_akSimplePlayerInfo, 0, sizeof(m_akSimplePlayerInfo));
for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i)
{
m_adwGuildID[i] = 0;
m_astrGuildName[i] = "";
}
NANOEND
}
void CPythonNetworkStream::__DirectEnterMode_Initialize()
{
m_kDirectEnterMode.m_isSet=false;
m_kDirectEnterMode.m_dwChrSlotIndex=0;
}
void CPythonNetworkStream::__DirectEnterMode_Set(UINT uChrSlotIndex)
{
m_kDirectEnterMode.m_isSet=true;
m_kDirectEnterMode.m_dwChrSlotIndex=uChrSlotIndex;
}
bool CPythonNetworkStream::__DirectEnterMode_IsSet()
{
return m_kDirectEnterMode.m_isSet;
}
void CPythonNetworkStream::__InitializeMarkAuth()
{
m_kMarkAuth.m_dwHandle=0;
m_kMarkAuth.m_dwRandomKey=0;
}
void CPythonNetworkStream::__BettingGuildWar_Initialize()
{
m_kBettingGuildWar.m_dwBettingMoney=0;
m_kBettingGuildWar.m_dwObserverCount=0;
}
void CPythonNetworkStream::__BettingGuildWar_SetObserverCount(UINT uObserverCount)
{
m_kBettingGuildWar.m_dwObserverCount=uObserverCount;
}
void CPythonNetworkStream::__BettingGuildWar_SetBettingMoney(UINT uBettingMoney)
{
m_kBettingGuildWar.m_dwBettingMoney=uBettingMoney;
}
DWORD CPythonNetworkStream::EXPORT_GetBettingGuildWarValue(const char* c_szValueName)
{
if (stricmp(c_szValueName, "OBSERVER_COUNT") == 0)
return m_kBettingGuildWar.m_dwObserverCount;
if (stricmp(c_szValueName, "BETTING_MONEY") == 0)
return m_kBettingGuildWar.m_dwBettingMoney;
return 0;
}
void CPythonNetworkStream::__ServerTimeSync_Initialize()
{
m_kServerTimeSync.m_dwChangeClientTime=0;
m_kServerTimeSync.m_dwChangeServerTime=0;
}
void CPythonNetworkStream::SetWaitFlag()
{
m_isWaitLoginKey = TRUE;
}
void CPythonNetworkStream::SendEmoticon(UINT eEmoticon)
{
if(eEmoticon < m_EmoticonStringVector.size())
SendChatPacket(m_EmoticonStringVector[eEmoticon].c_str());
else
assert(false && "SendEmoticon Error");
}
CPythonNetworkStream::CPythonNetworkStream()
{
m_rokNetActorMgr=new CNetworkActorManager;
memset(m_akSimplePlayerInfo, 0, sizeof(m_akSimplePlayerInfo));
m_phaseProcessFunc.Clear();
m_dwEmpireID = 0;
m_dwGuildID = 0;
m_dwMainActorVID = 0;
m_dwMainActorRace = 0;
m_dwMainActorEmpire = 0;
m_dwMainActorSkillGroup = 0;
m_poHandler = NULL;
m_dwLastGamePingTime = 0;
m_dwLoginKey = 0;
m_isWaitLoginKey = FALSE;
m_isStartGame = FALSE;
m_isEnableChatInsultFilter = FALSE;
m_bComboSkillFlag = FALSE;
m_strPhase = "OffLine";
__InitializeGamePhase();
__InitializeMarkAuth();
__DirectEnterMode_Initialize();
__BettingGuildWar_Initialize();
std::fill(m_apoPhaseWnd, m_apoPhaseWnd+PHASE_WINDOW_NUM, (PyObject*)NULL);
m_poSerCommandParserWnd = NULL;
SetOffLinePhase();
}
CPythonNetworkStream::~CPythonNetworkStream()
{
Tracen("PythonNetworkMainStream Clear");
}
| [
"59807064+Reizonr1@users.noreply.github.com"
] | 59807064+Reizonr1@users.noreply.github.com |
3eb3ea53c29200e6f8d5849feb8ecfc2a7889409 | 4a29645ac8423bc43bc93ffb6f127e2498147b55 | /Source/MellowsMegaRide/Public/MellowsGameOverUIWidget.h | b73549059c45c20894e76d8f836ac2a571acd0eb | [
"MIT"
] | permissive | Reuapmok/MellowsMegaRide | 1b40a981e3b69baee91a738fb3dda7257ed950c4 | 89f0f0fc834db5b04c790e87108b9393c3c65021 | refs/heads/master | 2023-04-03T14:29:24.105058 | 2021-04-19T09:53:45 | 2021-04-19T09:53:45 | 329,316,061 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,113 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "Blueprint/UserWidget.h"
#include "MellowsGameOverUIWidget.generated.h"
/**
*
*/
UCLASS()
class MELLOWSMEGARIDE_API UMellowsGameOverUIWidget : public UUserWidget
{
GENERATED_BODY()
public:
// default widget constructor
UMellowsGameOverUIWidget(const FObjectInitializer& ObjectInitialize);
virtual void NativeConstruct() override;
virtual void NativeTick(const FGeometry & MyGeometry, float DeltaSeconds) override;
void setScoreBoard(bool verdict);
// VERTICAL BOX
UPROPERTY(BlueprintReadWrite, meta = (BindWidget))
class UVerticalBox* PlayerVerdictBoard = nullptr;
// LIST OF WIDGETS
UPROPERTY(BlueprintReadWrite)
TArray<class UMellowsGameOverScoreUIWidget*> playerVerdictBoardEntries;
// Game end Text
UPROPERTY(BlueprintReadWrite, meta = (BindWidget))
class UTextBlock* GameEndText = nullptr;
TArray<class AMellowsPlayerState*> sortedPlayerList;
//UPROPERTY(BlueprintReadWrite, meta = (BindWidget))
// TArray<class UTextBlock*> playerList;
};
| [
"simon.kompauer@gmail.com"
] | simon.kompauer@gmail.com |
c68995b048a9a6b508e1ab2933f47b7a2668eeb4 | 5f58803edab530bc585e2b3a6d5d877e1e4215dc | /MonopolAdventure/donnees/graphismes/GraphismeJoueur.cpp | c64b3f6d639aaada96eb122eaa30cee1ced9a503 | [] | no_license | Vinorcola/MonopolAdventure | b96ae259a644498fb89969facd01b142121f66f6 | 7a15358fdaa261ec718f470a81b9b40307f6fcec | HEAD | 2016-09-06T03:26:09.768549 | 2013-09-08T18:36:53 | 2013-09-08T18:36:53 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 859 | cpp | #include "GraphismeJoueur.hpp"
GraphismeJoueur::GraphismeJoueur(QString couleur) :
QGraphicsPixmapItem(),
m_imageH(new QPixmap("data/joueurs/" + couleur + "H.bmp")),
m_imageB(new QPixmap("data/joueurs/" + couleur + "B.bmp")),
m_imageG(new QPixmap("data/joueurs/" + couleur + "G.bmp")),
m_imageD(new QPixmap("data/joueurs/" + couleur + "D.bmp"))
{
setPixmap(*m_imageB);
}
void GraphismeJoueur::changeOrientation(GraphismeJoueur::Orientation orientation)
{
switch (orientation)
{
case Haut:
setPixmap(*m_imageH);
break;
case Bas:
setPixmap(*m_imageB);
break;
case Gauche:
setPixmap(*m_imageG);
break;
case Droite:
setPixmap(*m_imageD);
break;
}
}
| [
"vinorcola@hotmail.fr"
] | vinorcola@hotmail.fr |
12c6a06ce819d13e5ad39a5b4653bc2cb53078e0 | 961714d4298245d9c762e59c716c070643af2213 | /ThirdParty-mod/java2cpp/android/inputmethodservice/KeyboardView.hpp | 2ceab2764e02c0b83f912140451ff8c7b2316054 | [
"MIT"
] | permissive | blockspacer/HQEngine | b072ff13d2c1373816b40c29edbe4b869b4c69b1 | 8125b290afa7c62db6cc6eac14e964d8138c7fd0 | refs/heads/master | 2023-04-22T06:11:44.953694 | 2018-10-02T15:24:43 | 2018-10-02T15:24:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 23,088 | hpp | /*================================================================================
code generated by: java2cpp
author: Zoran Angelov, mailto://baldzar@gmail.com
class: android.inputmethodservice.KeyboardView
================================================================================*/
#ifndef J2CPP_INCLUDE_IMPLEMENTATION
#ifndef J2CPP_ANDROID_INPUTMETHODSERVICE_KEYBOARDVIEW_HPP_DECL
#define J2CPP_ANDROID_INPUTMETHODSERVICE_KEYBOARDVIEW_HPP_DECL
namespace j2cpp { namespace java { namespace lang { class Object; } } }
namespace j2cpp { namespace java { namespace lang { class CharSequence; } } }
namespace j2cpp { namespace android { namespace inputmethodservice { class Keyboard; } } }
namespace j2cpp { namespace android { namespace inputmethodservice { namespace KeyboardView_ { class OnKeyboardActionListener; } } } }
namespace j2cpp { namespace android { namespace graphics { class Canvas; } } }
namespace j2cpp { namespace android { namespace content { class Context; } } }
namespace j2cpp { namespace android { namespace view { class View; } } }
namespace j2cpp { namespace android { namespace view { class MotionEvent; } } }
namespace j2cpp { namespace android { namespace view { namespace View_ { class OnClickListener; } } } }
namespace j2cpp { namespace android { namespace util { class AttributeSet; } } }
#include <android/content/Context.hpp>
#include <android/graphics/Canvas.hpp>
#include <android/inputmethodservice/Keyboard.hpp>
#include <android/inputmethodservice/KeyboardView.hpp>
#include <android/util/AttributeSet.hpp>
#include <android/view/MotionEvent.hpp>
#include <android/view/View.hpp>
#include <java/lang/CharSequence.hpp>
#include <java/lang/Object.hpp>
namespace j2cpp {
namespace android { namespace inputmethodservice {
class KeyboardView;
namespace KeyboardView_ {
class OnKeyboardActionListener;
class OnKeyboardActionListener
: public object<OnKeyboardActionListener>
{
public:
J2CPP_DECLARE_CLASS
J2CPP_DECLARE_METHOD(0)
J2CPP_DECLARE_METHOD(1)
J2CPP_DECLARE_METHOD(2)
J2CPP_DECLARE_METHOD(3)
J2CPP_DECLARE_METHOD(4)
J2CPP_DECLARE_METHOD(5)
J2CPP_DECLARE_METHOD(6)
J2CPP_DECLARE_METHOD(7)
explicit OnKeyboardActionListener(jobject jobj)
: object<OnKeyboardActionListener>(jobj)
{
}
operator local_ref<java::lang::Object>() const;
void onPress(jint);
void onRelease(jint);
void onKey(jint, local_ref< array<jint,1> > const&);
void onText(local_ref< java::lang::CharSequence > const&);
void swipeLeft();
void swipeRight();
void swipeDown();
void swipeUp();
}; //class OnKeyboardActionListener
} //namespace KeyboardView_
class KeyboardView
: public object<KeyboardView>
{
public:
J2CPP_DECLARE_CLASS
J2CPP_DECLARE_METHOD(0)
J2CPP_DECLARE_METHOD(1)
J2CPP_DECLARE_METHOD(2)
J2CPP_DECLARE_METHOD(3)
J2CPP_DECLARE_METHOD(4)
J2CPP_DECLARE_METHOD(5)
J2CPP_DECLARE_METHOD(6)
J2CPP_DECLARE_METHOD(7)
J2CPP_DECLARE_METHOD(8)
J2CPP_DECLARE_METHOD(9)
J2CPP_DECLARE_METHOD(10)
J2CPP_DECLARE_METHOD(11)
J2CPP_DECLARE_METHOD(12)
J2CPP_DECLARE_METHOD(13)
J2CPP_DECLARE_METHOD(14)
J2CPP_DECLARE_METHOD(15)
J2CPP_DECLARE_METHOD(16)
J2CPP_DECLARE_METHOD(17)
J2CPP_DECLARE_METHOD(18)
J2CPP_DECLARE_METHOD(19)
J2CPP_DECLARE_METHOD(20)
J2CPP_DECLARE_METHOD(21)
J2CPP_DECLARE_METHOD(22)
J2CPP_DECLARE_METHOD(23)
J2CPP_DECLARE_METHOD(24)
J2CPP_DECLARE_METHOD(25)
J2CPP_DECLARE_METHOD(26)
J2CPP_DECLARE_METHOD(27)
J2CPP_DECLARE_METHOD(28)
J2CPP_DECLARE_METHOD(29)
typedef KeyboardView_::OnKeyboardActionListener OnKeyboardActionListener;
explicit KeyboardView(jobject jobj)
: object<KeyboardView>(jobj)
{
}
operator local_ref<android::view::View>() const;
operator local_ref<android::view::View_::OnClickListener>() const;
KeyboardView(local_ref< android::content::Context > const&, local_ref< android::util::AttributeSet > const&);
KeyboardView(local_ref< android::content::Context > const&, local_ref< android::util::AttributeSet > const&, jint);
void setOnKeyboardActionListener(local_ref< android::inputmethodservice::KeyboardView_::OnKeyboardActionListener > const&);
void setKeyboard(local_ref< android::inputmethodservice::Keyboard > const&);
local_ref< android::inputmethodservice::Keyboard > getKeyboard();
jboolean setShifted(jboolean);
jboolean isShifted();
void setPreviewEnabled(jboolean);
jboolean isPreviewEnabled();
void setVerticalCorrection(jint);
void setPopupParent(local_ref< android::view::View > const&);
void setPopupOffset(jint, jint);
void setProximityCorrectionEnabled(jboolean);
jboolean isProximityCorrectionEnabled();
void onMeasure(jint, jint);
void onSizeChanged(jint, jint, jint, jint);
void onDraw(local_ref< android::graphics::Canvas > const&);
void invalidateAllKeys();
void invalidateKey(jint);
jboolean onTouchEvent(local_ref< android::view::MotionEvent > const&);
void closing();
void onDetachedFromWindow();
jboolean handleBack();
void onClick(local_ref< android::view::View > const&);
}; //class KeyboardView
} //namespace inputmethodservice
} //namespace android
} //namespace j2cpp
#endif //J2CPP_ANDROID_INPUTMETHODSERVICE_KEYBOARDVIEW_HPP_DECL
#else //J2CPP_INCLUDE_IMPLEMENTATION
#ifndef J2CPP_ANDROID_INPUTMETHODSERVICE_KEYBOARDVIEW_HPP_IMPL
#define J2CPP_ANDROID_INPUTMETHODSERVICE_KEYBOARDVIEW_HPP_IMPL
namespace j2cpp {
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::operator local_ref<java::lang::Object>() const
{
return local_ref<java::lang::Object>(get_jobject());
}
void android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::onPress(jint a0)
{
return call_method<
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_NAME(0),
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_SIGNATURE(0),
void
>(get_jobject(), a0);
}
void android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::onRelease(jint a0)
{
return call_method<
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_NAME(1),
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_SIGNATURE(1),
void
>(get_jobject(), a0);
}
void android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::onKey(jint a0, local_ref< array<jint,1> > const &a1)
{
return call_method<
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_NAME(2),
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_SIGNATURE(2),
void
>(get_jobject(), a0, a1);
}
void android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::onText(local_ref< java::lang::CharSequence > const &a0)
{
return call_method<
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_NAME(3),
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_SIGNATURE(3),
void
>(get_jobject(), a0);
}
void android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::swipeLeft()
{
return call_method<
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_NAME(4),
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_SIGNATURE(4),
void
>(get_jobject());
}
void android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::swipeRight()
{
return call_method<
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_NAME(5),
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_SIGNATURE(5),
void
>(get_jobject());
}
void android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::swipeDown()
{
return call_method<
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_NAME(6),
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_SIGNATURE(6),
void
>(get_jobject());
}
void android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::swipeUp()
{
return call_method<
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_NAME(7),
android::inputmethodservice::KeyboardView_::OnKeyboardActionListener::J2CPP_METHOD_SIGNATURE(7),
void
>(get_jobject());
}
J2CPP_DEFINE_CLASS(android::inputmethodservice::KeyboardView_::OnKeyboardActionListener,"android/inputmethodservice/KeyboardView$OnKeyboardActionListener")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView_::OnKeyboardActionListener,0,"onPress","(I)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView_::OnKeyboardActionListener,1,"onRelease","(I)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView_::OnKeyboardActionListener,2,"onKey","(I[I)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView_::OnKeyboardActionListener,3,"onText","(Ljava/lang/CharSequence;)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView_::OnKeyboardActionListener,4,"swipeLeft","()V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView_::OnKeyboardActionListener,5,"swipeRight","()V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView_::OnKeyboardActionListener,6,"swipeDown","()V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView_::OnKeyboardActionListener,7,"swipeUp","()V")
android::inputmethodservice::KeyboardView::operator local_ref<android::view::View>() const
{
return local_ref<android::view::View>(get_jobject());
}
android::inputmethodservice::KeyboardView::operator local_ref<android::view::View_::OnClickListener>() const
{
return local_ref<android::view::View_::OnClickListener>(get_jobject());
}
android::inputmethodservice::KeyboardView::KeyboardView(local_ref< android::content::Context > const &a0, local_ref< android::util::AttributeSet > const &a1)
: object<android::inputmethodservice::KeyboardView>(
call_new_object<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(0),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(0)
>(a0, a1)
)
{
}
android::inputmethodservice::KeyboardView::KeyboardView(local_ref< android::content::Context > const &a0, local_ref< android::util::AttributeSet > const &a1, jint a2)
: object<android::inputmethodservice::KeyboardView>(
call_new_object<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(1),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(1)
>(a0, a1, a2)
)
{
}
void android::inputmethodservice::KeyboardView::setOnKeyboardActionListener(local_ref< android::inputmethodservice::KeyboardView_::OnKeyboardActionListener > const &a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(2),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(2),
void
>(get_jobject(), a0);
}
void android::inputmethodservice::KeyboardView::setKeyboard(local_ref< android::inputmethodservice::Keyboard > const &a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(4),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(4),
void
>(get_jobject(), a0);
}
local_ref< android::inputmethodservice::Keyboard > android::inputmethodservice::KeyboardView::getKeyboard()
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(5),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(5),
local_ref< android::inputmethodservice::Keyboard >
>(get_jobject());
}
jboolean android::inputmethodservice::KeyboardView::setShifted(jboolean a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(6),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(6),
jboolean
>(get_jobject(), a0);
}
jboolean android::inputmethodservice::KeyboardView::isShifted()
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(7),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(7),
jboolean
>(get_jobject());
}
void android::inputmethodservice::KeyboardView::setPreviewEnabled(jboolean a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(8),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(8),
void
>(get_jobject(), a0);
}
jboolean android::inputmethodservice::KeyboardView::isPreviewEnabled()
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(9),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(9),
jboolean
>(get_jobject());
}
void android::inputmethodservice::KeyboardView::setVerticalCorrection(jint a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(10),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(10),
void
>(get_jobject(), a0);
}
void android::inputmethodservice::KeyboardView::setPopupParent(local_ref< android::view::View > const &a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(11),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(11),
void
>(get_jobject(), a0);
}
void android::inputmethodservice::KeyboardView::setPopupOffset(jint a0, jint a1)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(12),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(12),
void
>(get_jobject(), a0, a1);
}
void android::inputmethodservice::KeyboardView::setProximityCorrectionEnabled(jboolean a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(13),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(13),
void
>(get_jobject(), a0);
}
jboolean android::inputmethodservice::KeyboardView::isProximityCorrectionEnabled()
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(14),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(14),
jboolean
>(get_jobject());
}
void android::inputmethodservice::KeyboardView::onMeasure(jint a0, jint a1)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(15),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(15),
void
>(get_jobject(), a0, a1);
}
void android::inputmethodservice::KeyboardView::onSizeChanged(jint a0, jint a1, jint a2, jint a3)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(16),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(16),
void
>(get_jobject(), a0, a1, a2, a3);
}
void android::inputmethodservice::KeyboardView::onDraw(local_ref< android::graphics::Canvas > const &a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(17),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(17),
void
>(get_jobject(), a0);
}
void android::inputmethodservice::KeyboardView::invalidateAllKeys()
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(18),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(18),
void
>(get_jobject());
}
void android::inputmethodservice::KeyboardView::invalidateKey(jint a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(19),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(19),
void
>(get_jobject(), a0);
}
jboolean android::inputmethodservice::KeyboardView::onTouchEvent(local_ref< android::view::MotionEvent > const &a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(21),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(21),
jboolean
>(get_jobject(), a0);
}
void android::inputmethodservice::KeyboardView::closing()
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(26),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(26),
void
>(get_jobject());
}
void android::inputmethodservice::KeyboardView::onDetachedFromWindow()
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(27),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(27),
void
>(get_jobject());
}
jboolean android::inputmethodservice::KeyboardView::handleBack()
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(28),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(28),
jboolean
>(get_jobject());
}
void android::inputmethodservice::KeyboardView::onClick(local_ref< android::view::View > const &a0)
{
return call_method<
android::inputmethodservice::KeyboardView::J2CPP_CLASS_NAME,
android::inputmethodservice::KeyboardView::J2CPP_METHOD_NAME(29),
android::inputmethodservice::KeyboardView::J2CPP_METHOD_SIGNATURE(29),
void
>(get_jobject(), a0);
}
J2CPP_DEFINE_CLASS(android::inputmethodservice::KeyboardView,"android/inputmethodservice/KeyboardView")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,0,"<init>","(Landroid/content/Context;Landroid/util/AttributeSet;)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,1,"<init>","(Landroid/content/Context;Landroid/util/AttributeSet;I)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,2,"setOnKeyboardActionListener","(Landroid/inputmethodservice/KeyboardView$OnKeyboardActionListener;)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,3,"getOnKeyboardActionListener","()Landroid/inputmethodservice/KeyboardView$OnKeyboardActionListener;")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,4,"setKeyboard","(Landroid/inputmethodservice/Keyboard;)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,5,"getKeyboard","()Landroid/inputmethodservice/Keyboard;")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,6,"setShifted","(Z)Z")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,7,"isShifted","()Z")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,8,"setPreviewEnabled","(Z)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,9,"isPreviewEnabled","()Z")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,10,"setVerticalCorrection","(I)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,11,"setPopupParent","(Landroid/view/View;)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,12,"setPopupOffset","(II)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,13,"setProximityCorrectionEnabled","(Z)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,14,"isProximityCorrectionEnabled","()Z")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,15,"onMeasure","(II)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,16,"onSizeChanged","(IIII)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,17,"onDraw","(Landroid/graphics/Canvas;)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,18,"invalidateAllKeys","()V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,19,"invalidateKey","(I)V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,20,"onLongPress","(Landroid/inputmethodservice/Keyboard$Key;)Z")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,21,"onTouchEvent","(Landroid/view/MotionEvent;)Z")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,22,"swipeRight","()V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,23,"swipeLeft","()V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,24,"swipeUp","()V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,25,"swipeDown","()V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,26,"closing","()V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,27,"onDetachedFromWindow","()V")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,28,"handleBack","()Z")
J2CPP_DEFINE_METHOD(android::inputmethodservice::KeyboardView,29,"onClick","(Landroid/view/View;)V")
} //namespace j2cpp
#endif //J2CPP_ANDROID_INPUTMETHODSERVICE_KEYBOARDVIEW_HPP_IMPL
#endif //J2CPP_INCLUDE_IMPLEMENTATION
| [
"le.hoang.q@gmail.com@2e56ffda-155b-7872-b1f3-609f5c043f28"
] | le.hoang.q@gmail.com@2e56ffda-155b-7872-b1f3-609f5c043f28 |
fdb7b963d8d6e8ebd77a67265bb13549db1bf367 | 0342fe0e71b63481ffa104eb0f2d127409021bae | /export/mac64/cpp/obj/include/flixel/animation/FlxPrerotatedAnimation.h | ba6da1ed23108fef1d6ed9eabad369f34e130df6 | [] | no_license | azlen/LD36 | a063027afe49a219eb0a3711e12a3a9f553bc410 | 2b800e01ee491631974a6abd28a12f5019cb430a | refs/heads/master | 2020-12-02T17:10:09.618613 | 2016-08-29T02:02:00 | 2016-08-29T02:02:00 | 66,799,278 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | true | 2,297 | h | // Generated by Haxe 3.3.0
#ifndef INCLUDED_flixel_animation_FlxPrerotatedAnimation
#define INCLUDED_flixel_animation_FlxPrerotatedAnimation
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
#ifndef INCLUDED_flixel_animation_FlxBaseAnimation
#include <flixel/animation/FlxBaseAnimation.h>
#endif
HX_DECLARE_CLASS2(flixel,animation,FlxAnimationController)
HX_DECLARE_CLASS2(flixel,animation,FlxBaseAnimation)
HX_DECLARE_CLASS2(flixel,animation,FlxPrerotatedAnimation)
HX_DECLARE_CLASS2(flixel,util,IFlxDestroyable)
namespace flixel{
namespace animation{
class HXCPP_CLASS_ATTRIBUTES FlxPrerotatedAnimation_obj : public ::flixel::animation::FlxBaseAnimation_obj
{
public:
typedef ::flixel::animation::FlxBaseAnimation_obj super;
typedef FlxPrerotatedAnimation_obj OBJ_;
FlxPrerotatedAnimation_obj();
public:
void __construct( ::flixel::animation::FlxAnimationController Parent,Float Baked);
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="flixel.animation.FlxPrerotatedAnimation")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"flixel.animation.FlxPrerotatedAnimation"); }
static hx::ObjectPtr< FlxPrerotatedAnimation_obj > __new( ::flixel::animation::FlxAnimationController Parent,Float Baked);
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~FlxPrerotatedAnimation_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
::String __ToString() const { return HX_HCSTRING("FlxPrerotatedAnimation","\x0c","\xd5","\x4f","\xad"); }
static void __boot();
static ::String PREROTATED;
Int rotations;
Float baked;
Float angle;
Float set_angle(Float Value);
::Dynamic set_angle_dyn();
Int set_curIndex(Int Value);
::flixel::animation::FlxBaseAnimation clone( ::flixel::animation::FlxAnimationController Parent);
};
} // end namespace flixel
} // end namespace animation
#endif /* INCLUDED_flixel_animation_FlxPrerotatedAnimation */
| [
"azlen@livingcode.org"
] | azlen@livingcode.org |
eaec587d71abb019d477b0ec0ee625a5d8e69644 | e70d0bcc547d63b338ff51c253aa95d78ea99992 | /blaze/blaze/operator/op/elementwise_op.cc | 57674f6cee7f05bac2d27b2afd31cef4a7c4964a | [
"Apache-2.0"
] | permissive | niumeng07/x-deeplearning | 2513f7ba823521c40e0346284f5dd0aca5562e40 | 6d3bc3ad4996ab8938c56d8a834af07a04dc2f67 | refs/heads/master | 2020-04-12T23:06:24.447833 | 2019-07-06T16:06:16 | 2019-07-06T16:06:16 | 162,808,758 | 2 | 0 | Apache-2.0 | 2018-12-22T12:18:01 | 2018-12-22T12:17:59 | null | UTF-8 | C++ | false | false | 15,579 | cc | /*
* \file elementwise_op.cc
* \desc The elementwise operator on cpu implementation
*/
#include "blaze/operator/op/elementwise_op.h"
#include "blaze/operator/common_helper.h"
#include "blaze/math/elementwise/broadcast_elementwise.h"
#include "blaze/math/elementwise/cpu_kernel_launcher.h"
#include "blaze/math/elementwise/elementwise_kernel.h"
#include "blaze/math/vml.h"
namespace blaze {
#ifndef RUN_ELEMENTWISE_OP_KERNEL
#define RUN_ELEMENTWISE_OP_KERNEL(kernel) \
do { \
Blob* a = this->Input(0); \
Blob* b = this->InputSize() < 2 ? this->Output(0) : this->Input(1); \
Blob* c = this->Output(0); \
\
CheckValid(); \
Reshape(); \
bool need_broadcast = NeedBroadcast(); \
\
TYPE_SWITCH(a->data_type(), DType, { \
ElementwiseParam<DType> params(a->as<DType>(), a->size(), a->shape(), \
b->as<DType>(), b->size(), b->shape(), \
c->as<DType>(), c->size(), c->shape()); \
return kernel(params, need_broadcast, context()); \
}); \
} while (0)
#endif
template <typename DType, class Context>
bool AddKernel(ElementwiseParam<DType>& params, bool need_broadcast, const Context& context) {
if (need_broadcast) {
bool res = broadcast::BroadcastCompute<DType, broadcast::Sum, CpuKernelLauncher, CPUContext>(
params.x, params.x_shape, params.y, params.y_shape,
params.z, params.z_shape, context);
return res;
}
VML_Add<DType, CPUContext>(params.z_n, params.x, params.y, params.z, nullptr);
return true;
}
template <>
bool ElementwiseAddOp<CPUContext>::RunOnDevice() {
RUN_ELEMENTWISE_OP_KERNEL(AddKernel);
}
REGISTER_CPU_OPERATOR(Add, ElementwiseAddOp<CPUContext>);
// Input: a, b Output: c
OPERATOR_SCHEMA(Add)
.NumInputs(2)
.NumOutputs(1)
.IdenticalTypeOfInput(0)
.AllowInplace({{0, 0}, {1, 0}})
.SetAttr<bool>(kAttrIsElementWise, true)
.CostInferenceFunction([](const OperatorDef& def,
const std::vector<TensorShape>& input_shape,
const std::vector<DataType>& input_type,
const std::vector<TensorShape>& output_shape,
const std::vector<DataType>& output_type) {
return ElementWiseCostInference<1>(def, input_shape, input_type, output_shape, output_type);
})
.SetDoc(R"DOC(
a + b = c
)DOC");
template <typename DType, class Context>
bool SubKernel(ElementwiseParam<DType>& params, bool need_broadcast, const Context& context) {
if (need_broadcast) {
bool res = broadcast::BroadcastCompute<DType, broadcast::Sub, CpuKernelLauncher, CPUContext>(
params.x, params.x_shape, params.y, params.y_shape,
params.z, params.z_shape, context);
return res;
}
VML_Sub<DType, CPUContext>(params.z_n, params.x, params.y, params.z, nullptr);
return true;
}
template <>
bool ElementwiseSubOp<CPUContext>::RunOnDevice() {
RUN_ELEMENTWISE_OP_KERNEL(SubKernel);
}
REGISTER_CPU_OPERATOR(Sub, ElementwiseSubOp<CPUContext>);
// Input: a, b Output: c
OPERATOR_SCHEMA(Sub)
.NumInputs(2)
.NumOutputs(1)
.IdenticalTypeOfInput(0)
.AllowInplace({{0, 0}, {1, 0}})
.SetAttr<bool>(kAttrIsElementWise, true)
.CostInferenceFunction([](const OperatorDef& def,
const std::vector<TensorShape>& input_shape,
const std::vector<DataType>& input_type,
const std::vector<TensorShape>& output_shape,
const std::vector<DataType>& output_type) {
return ElementWiseCostInference<1>(def, input_shape, input_type, output_shape, output_type);
})
.SetDoc(R"DOC(
a - b = c
)DOC");
template <typename DType, class Context>
bool MulKernel(ElementwiseParam<DType>& params, bool need_broadcast, const Context& context) {
if (need_broadcast) {
bool res = broadcast::BroadcastCompute<DType, broadcast::Mul, CpuKernelLauncher, CPUContext>(
params.x, params.x_shape, params.y, params.y_shape,
params.z, params.z_shape, context);
return res;
}
VML_Mul<DType, CPUContext>(params.z_n, params.x, params.y, params.z, nullptr);
return true;
}
template <>
bool ElementwiseMulOp<CPUContext>::RunOnDevice() {
RUN_ELEMENTWISE_OP_KERNEL(MulKernel);
}
REGISTER_CPU_OPERATOR(Mul, ElementwiseMulOp<CPUContext>);
// Input: a, b Output: c
OPERATOR_SCHEMA(Mul)
.NumInputs(2)
.NumOutputs(1)
.IdenticalTypeOfInput(0)
.AllowInplace({{0, 0}, {1, 0}})
.SetAttr<bool>(kAttrIsElementWise, true)
.CostInferenceFunction([](const OperatorDef& def,
const std::vector<TensorShape>& input_shape,
const std::vector<DataType>& input_type,
const std::vector<TensorShape>& output_shape,
const std::vector<DataType>& output_type) {
return ElementWiseCostInference<1>(def, input_shape, input_type, output_shape, output_type);
})
.SetDoc(R"DOC(
a * b = c
)DOC");
template <typename DType, class Context>
bool DivKernel(ElementwiseParam<DType>& params, bool need_broadcast, const Context& context) {
if (need_broadcast) {
bool res = broadcast::BroadcastCompute<DType, broadcast::Div, CpuKernelLauncher, CPUContext>(
params.x, params.x_shape, params.y, params.y_shape,
params.z, params.z_shape, context);
return res;
}
VML_Div<DType, CPUContext>(params.z_n, params.x, params.y, params.z, nullptr);
return true;
}
template <>
bool ElementwiseDivOp<CPUContext>::RunOnDevice() {
RUN_ELEMENTWISE_OP_KERNEL(DivKernel);
}
REGISTER_CPU_OPERATOR(Div, ElementwiseDivOp<CPUContext>);
// Input: a, b Output: c
OPERATOR_SCHEMA(Div)
.NumInputs(2)
.NumOutputs(1)
.IdenticalTypeOfInput(0)
.AllowInplace({{0, 0}, {1, 0}})
.SetAttr<bool>(kAttrIsElementWise, true)
.CostInferenceFunction([](const OperatorDef& def,
const std::vector<TensorShape>& input_shape,
const std::vector<DataType>& input_type,
const std::vector<TensorShape>& output_shape,
const std::vector<DataType>& output_type) {
return ElementWiseCostInference<1>(def, input_shape, input_type, output_shape, output_type);
})
.SetDoc(R"DOC(
a / b = c
)DOC");
template <typename DType, class Context>
bool EqualKernel(ElementwiseParam<DType>& params, bool need_broadcast, const Context& context) {
if (need_broadcast) {
bool res = broadcast::BroadcastCompute<DType, broadcast::Equal, CpuKernelLauncher, CPUContext>(
params.x, params.x_shape, params.y, params.y_shape,
params.z, params.z_shape, context);
return res;
}
for (size_t i = 0; i < params.z_n; ++i) {
params.z[i] = params.x[i % params.x_n] == params.y[i % params.y_n] ? 1 : 0;
}
return true;
}
template <>
bool ElementwiseEqualOp<CPUContext>::RunOnDevice() {
RUN_ELEMENTWISE_OP_KERNEL(EqualKernel);
}
REGISTER_CPU_OPERATOR(Equal, ElementwiseEqualOp<CPUContext>);
// Input: a, b Output: c
OPERATOR_SCHEMA(Equal)
.NumInputs(2)
.NumOutputs(1)
.AllowInplace({{0, 0}, {1, 0}})
.SetAttr<bool>(kAttrIsElementWise, true)
.CostInferenceFunction([](const OperatorDef& def,
const std::vector<TensorShape>& input_shape,
const std::vector<DataType>& input_type,
const std::vector<TensorShape>& output_shape,
const std::vector<DataType>& output_type) {
return ElementWiseCostInference<1>(def, input_shape, input_type, output_shape, output_type);
})
.SetDoc(R"DOC(
c = (a == b)
)DOC");
template <typename DType, class Context>
bool NotEqualKernel(ElementwiseParam<DType>& params, bool need_broadcast, const Context& context) {
if (need_broadcast) {
bool res = broadcast::BroadcastCompute<DType, broadcast::NotEqual, CpuKernelLauncher, CPUContext>(
params.x, params.x_shape, params.y, params.y_shape,
params.z, params.z_shape, context);
return res;
}
for (size_t i = 0; i < params.z_n; ++i) {
params.z[i] = params.x[i % params.x_n] == params.y[i % params.y_n] ? 0 : 1;
}
return true;
}
template <>
bool ElementwiseNotEqualOp<CPUContext>::RunOnDevice() {
RUN_ELEMENTWISE_OP_KERNEL(NotEqualKernel);
}
REGISTER_CPU_OPERATOR(NotEqual, ElementwiseNotEqualOp<CPUContext>);
// Input: a, b Output: c
OPERATOR_SCHEMA(NotEqual)
.NumInputs(2)
.NumOutputs(1)
.AllowInplace({{0, 0}, {1, 0}})
.SetAttr<bool>(kAttrIsElementWise, true)
.CostInferenceFunction([](const OperatorDef& def,
const std::vector<TensorShape>& input_shape,
const std::vector<DataType>& input_type,
const std::vector<TensorShape>& output_shape,
const std::vector<DataType>& output_type) {
return ElementWiseCostInference<1>(def, input_shape, input_type, output_shape, output_type);
})
.SetDoc(R"DOC(
c = (a != b)
)DOC");
template <typename DType, class Context>
bool MaxKernel(ElementwiseParam<DType>& params, bool need_broadcast, const Context& context) {
if (need_broadcast) {
bool res = broadcast::BroadcastCompute<DType, broadcast::Max, CpuKernelLauncher, CPUContext>(
params.x, params.x_shape, params.y, params.y_shape,
params.z, params.z_shape, context);
return res;
}
for (size_t i = 0; i < params.z_n; ++i) {
params.z[i] = std::max(params.x[i % params.x_n], params.y[i % params.y_n]);
}
return true;
}
template <>
bool ElementwiseMaxOp<CPUContext>::RunOnDevice() {
RUN_ELEMENTWISE_OP_KERNEL(MaxKernel);
}
REGISTER_CPU_OPERATOR(Max, ElementwiseMaxOp<CPUContext>);
// Input: a, b Output: c
OPERATOR_SCHEMA(Max)
.NumInputs(2)
.NumOutputs(1)
.AllowInplace({{0, 0}, {1, 0}})
.SetAttr<bool>(kAttrIsElementWise, true)
.CostInferenceFunction([](const OperatorDef& def,
const std::vector<TensorShape>& input_shape,
const std::vector<DataType>& input_type,
const std::vector<TensorShape>& output_shape,
const std::vector<DataType>& output_type) {
return ElementWiseCostInference<1>(def, input_shape, input_type, output_shape, output_type);
})
.SetDoc(R"DOC(
c = (a > b ? a : b)
)DOC");
template <typename DType, class Context>
bool MinKernel(ElementwiseParam<DType>& params, bool need_broadcast, const Context& context) {
if (need_broadcast) {
bool res = broadcast::BroadcastCompute<DType, broadcast::Min, CpuKernelLauncher, CPUContext>(
params.x, params.x_shape, params.y, params.y_shape,
params.z, params.z_shape, context);
return res;
}
for (size_t i = 0; i < params.z_n; ++i) {
params.z[i] = std::min(params.x[i % params.x_n], params.y[i % params.y_n]);
}
return true;
}
template <>
bool ElementwiseMinOp<CPUContext>::RunOnDevice() {
RUN_ELEMENTWISE_OP_KERNEL(MinKernel);
}
REGISTER_CPU_OPERATOR(Min, ElementwiseMinOp<CPUContext>);
// Input: a, b Output: c
OPERATOR_SCHEMA(Min)
.NumInputs(2)
.NumOutputs(1)
.AllowInplace({{0, 0}, {1, 0}})
.SetAttr<bool>(kAttrIsElementWise, true)
.CostInferenceFunction([](const OperatorDef& def,
const std::vector<TensorShape>& input_shape,
const std::vector<DataType>& input_type,
const std::vector<TensorShape>& output_shape,
const std::vector<DataType>& output_type) {
return ElementWiseCostInference<1>(def, input_shape, input_type, output_shape, output_type);
})
.SetDoc(R"DOC(
c = (a > b ? b : a)
)DOC");
template <typename DType, class Context>
bool BroadcastToKernel(ElementwiseParam<DType>& params, bool need_broadcast, const Context& context) {
if (need_broadcast) {
bool res = broadcast::BroadcastCompute<DType, broadcast::Assign, CpuKernelLauncher, CPUContext>(
params.x, params.x_shape, params.y, params.y_shape,
params.z, params.z_shape, context);
return res;
}
for (size_t i = 0; i < params.z_n; ++i) {
params.z[i] = params.x[i % params.x_n];
}
return true;
}
template <>
bool BroadcastToOp<CPUContext>::RunOnDevice() {
RUN_ELEMENTWISE_OP_KERNEL(BroadcastToKernel);
}
REGISTER_CPU_OPERATOR(BroadcastTo, BroadcastToOp<CPUContext>);
// Input: a, b Output: c
OPERATOR_SCHEMA(BroadcastTo)
.NumInputs(1, 2)
.NumOutputs(1)
.AllowInplace({{0, 0}, {1, 0}})
.SetAttr<bool>(kAttrIsElementWise, true)
.CostInferenceFunction([](const OperatorDef& def,
const std::vector<TensorShape>& input_shape,
const std::vector<DataType>& input_type,
const std::vector<TensorShape>& output_shape,
const std::vector<DataType>& output_type) {
return ElementWiseCostInference<1>(def, input_shape, input_type, output_shape, output_type);
})
.SetDoc(R"DOC(
c = BroadcastTo(a)
)DOC");
template <typename IType, typename DType, class Context>
static bool WhereKernel(TernaryElementwiseParam<IType, DType>& params, bool need_broadcast, const Context& context) {
if (need_broadcast) {
bool res = broadcast::BroadcastCompute<IType, DType, broadcast::Where, CpuKernelLauncher, CPUContext>(
params.condition, params.condition_shape,
params.x, params.x_shape, params.y, params.y_shape,
params.z, params.z_shape, context);
return res;
}
VML_Where<IType, DType, CPUContext>(params.z_n, params.condition, params.x, params.y, params.z, nullptr);
return true;
}
template <>
bool WhereOp<CPUContext>::RunOnDevice() {
Blob* condition = this->Input(0);
Blob* x = this->Input(1);
Blob* y = this->Input(2);
Blob* z = this->Output(0);
CheckValid();
Reshape();
bool need_broadcast = NeedBroadcast();
ID_TYPE_SWITCH(condition->data_type(), IType, {
TYPE_SWITCH(x->data_type(), DType, {
TernaryElementwiseParam<IType, DType> params(condition->as<IType>(), condition->size(), condition->shape(),
x->as<DType>(), x->size(), x->shape(),
y->as<DType>(), y->size(), y->shape(),
z->as<DType>(), z->size(), z->shape());
WhereKernel<IType, DType, CPUContext>(params, need_broadcast, this->context_);
});
});
return true;
}
REGISTER_CPU_OPERATOR(Where, WhereOp<CPUContext>);
// Input: condition X Y Output: Z
OPERATOR_SCHEMA(Where)
.NumInputs(3)
.NumOutputs(1)
.IdenticalTypeOfInput(1)
.SetDoc(R"DOC(
Return elements, either from X or Y, depending on condition
)DOC")
.Input(0, "condition", "When True (nonzero), yield X, otherwise yield Y")
.Input(1, "X", "N-D Input tensor")
.Input(2, "Y", "N-D Input tensor")
.Output(0, "Z", "N-D output tensor");
#undef RUN_ELEMENTWISE_OP_KERNEL
} // namespace blaze
| [
"yue.song@alibaba-inc.com"
] | yue.song@alibaba-inc.com |
6a947fec21d4f7b1c9f7b2995f12747d6c1c5426 | 9b48da12e8d70fb3d633b988b9c7d63a954434bf | /ECC8.1/Server/kennel/monitor/unix/monitor/Foundry.cpp | be118301413af987919177d8d90e27e4007e1776 | [
"Apache-2.0"
] | permissive | SiteView/ECC8.1.3 | 446e222e33f37f0bb6b67a9799e1353db6308095 | 7d7d8c7e7d7e7e03fa14f9f0e3ce5e04aacdb033 | refs/heads/master | 2021-01-01T18:07:05.104362 | 2012-08-30T08:58:28 | 2012-08-30T08:58:28 | 4,735,167 | 1 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 16,620 | cpp |
#include "Foundry.h"
#include "SnmpUtils.h"
#include "base\funcGeneral.h"
/* The statistics collection of 1 second CPU utilization. */
struct oid snAgGblCpuUtil1SecAvg = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 50}, 11, "", ASN1_GAUGE, ""};
/* The statistics collection of 5 second CPU utilization. */
struct oid snAgGblCpuUtil5SecAvg = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 51}, 11, "", ASN1_GAUGE, ""};
/* The statistics collection of 1 minute CPU utilization. */
struct oid snAgGblCpuUtil1MinAvg = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 52}, 11, "", ASN1_GAUGE, ""};
/* -- System CPU Utilization Table. */
struct oid snAgentCpuUtilTable = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 11, 1}, 11, "", 0, ""};
/* The slot number of module which contains the cpu. */
struct oid snAgentCpuUtilSlotNum = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 11, 1, 1, 1}, 13, "", ASN1_INT, ""};
/* The id of cpu. For non-VM1/WSM management module, there is one CPU. For VM1/WSM
there's one management CPU and three slave CPUs. The management CPU could be
turned off. For POS and ATM there's no management CPU but two slave CPUs. Id for
management cpu is 1. Value of 2 or greater are for slave CPUs. */
struct oid snAgentCpuUtilCpuId = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 11, 1, 1, 2}, 13, "", ASN1_INT, ""};
/* The value, in seconds, for this utilization. For both management and slave CPU,
we display utilization for 1 sec, 5 sec, 60 sec and 300 sec interval. */
struct oid snAgentCpuUtilInterval = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 11, 1, 1, 3}, 13, "", ASN1_INT, ""};
/* The statistical CPU utilization in units of one-hundredth of a percent. */
struct oid snAgentCpuUtilValue = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 11, 1, 1, 4}, 13, "", ASN1_GAUGE, ""};
BOOL FOUNDRYCPUS_MONITOR(char *server, int port, char *community, char *cpath, char *szReturn)
{
BOOL bResult = TRUE;
struct oid *poid = NULL, *proid = NULL, *pnextoid = NULL;
struct snval *psnval = NULL, *ptmpsnval = NULL;
int s;
struct sockaddr_in serv;
if(MakeSocket(server, port, s, serv) < 0)
{
return FALSE;
}
poid = (struct oid *)malloc(sizeof(struct oid));
proid = (struct oid *)malloc(sizeof(struct oid));
psnval = (struct snval *)malloc(sizeof(struct snval));
if(poid == NULL || proid == NULL || psnval == NULL)
{
bResult = FALSE;
goto err;
}
memset(poid, 0, sizeof(struct oid));
memset(proid, 0, sizeof(struct oid));
memset(psnval, 0, sizeof(struct snval));
memcpy(poid, &snAgentCpuUtilTable, sizeof(struct oid));
if(SN_NEXT_VALUE(s, serv, community, 1, poid, proid, psnval) < 0)
{
bResult = FALSE;
goto err;
}
while(!compare_oid(*proid, snAgentCpuUtilSlotNum))
{
sprintf(szReturn, "%s%d$$$", szReturn, psnval->sv_val.sv_int);
memcpy(poid, proid, sizeof(struct oid));
memset(proid, 0, sizeof(struct oid));
memset(psnval, 0, sizeof(struct snval));
if(SN_NEXT_VALUE(s, serv, community, 1, poid, proid, psnval) < 0)
{
bResult = FALSE;
goto err;
}
}
err:
if(poid) { free(poid); poid = NULL; }
if(proid) { free(proid); proid = NULL; }
if(psnval) { free(psnval); psnval = NULL; }
return bResult;
}
BOOL FOUNDRYCPU2_MONITOR(char *server, int port, char *community, CString strIndex,
int rdelay, int timeout, char *cpath, char *szReturn)
{
int s;
struct sockaddr_in serv;
int i = 0, ret = 0;
BOOL bResult = TRUE;
int count = 1;
struct snval *ptmp = NULL;
struct snval *ptmpnext = NULL;
if((ret = MakeSocket(server, port, s, serv)) < 0)
{
if(ret == -1)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_1%>"));//<%IDS_F5_1%>
else if(ret == -2)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_2%>"));//<%IDS_F5_2%>
else
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_3%>"));//<%IDS_F5_3%>
return FALSE;
}
long index_id[32];
int index_id_c = 0;
while(1)
{
i = strIndex.Find('.', 0);
if(i > 0)
index_id[index_id_c++] = atoi(strIndex);
else if(i < 0 && strIndex.GetLength() > 0)
{
index_id[index_id_c++] = atoi(strIndex);
break;
}
else
break;
strIndex.Delete(0, i + 1);
}
for(i = 0;i < index_id_c;i ++)
{
snAgGblCpuUtil1SecAvg.id[snAgGblCpuUtil1SecAvg.len ++] = index_id[i];
snAgGblCpuUtil5SecAvg.id[snAgGblCpuUtil5SecAvg.len ++] = index_id[i];
snAgGblCpuUtil1MinAvg.id[snAgGblCpuUtil1MinAvg.len ++] = index_id[i];
}
struct oid *poid = NULL, *ptmpoid = NULL;
poid = ptmpoid = &snAgGblCpuUtil1SecAvg;
ptmpoid->next = &snAgGblCpuUtil5SecAvg;
ptmpoid = ptmpoid->next;
ptmpoid->next = &snAgGblCpuUtil1MinAvg;
ptmpoid = ptmpoid->next;
struct snval *psnval = NULL;
if((ret = SN_VALUES(s, serv, community, 1, poid, &psnval)) < 0)
{
if(ret == -1)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_4%>"));//<%IDS_F5_4%>
else if(ret == -2)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_5%>"));//<%IDS_F5_5%>
else if(ret == -3)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_6%>"));//<%IDS_F5_6%>
else if(ret == -4)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_7%>"));//<%IDS_F5_7%>
else if(ret == -5)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_8%>"));//<%IDS_F5_8%>
else if(ret == -6)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_9%>"));//<%IDS_F5_9%>
else if(ret == -7)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_10%>"));//<%IDS_F5_10%>
else if(ret == -8)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_11%>"));//<%IDS_F5_11%>
else
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_12%>"));//<%IDS_F5_12%>
bResult = FALSE;
goto w;
}
ptmp = psnval;
ptmpnext = NULL;
while(ptmp)
{
switch(count)
{
case 1:
sprintf(szReturn, "%s=", "snAgGblCpuUtil1SecAvg");
break;
case 2:
sprintf(szReturn, "%s%s=", szReturn, "snAgGblCpuUtil5SecAvg");
break;
case 3:
sprintf(szReturn, "%s%s=", szReturn, "snAgGblCpuUtil1MinAvg");
break;
}
switch(ptmp->sv_type)
{
case ASN1_INT:
sprintf(szReturn, "%s%d$", szReturn, ptmp->sv_val.sv_int);
break;
case ASN1_COUNTER:
case ASN1_GAUGE:
case ASN1_TIMETICKS:
case ASN1_COUNTER64:
case ASN1_UINTEGER32:
sprintf(szReturn, "%s%u$", szReturn, ptmp->sv_val.sv_int);
break;
}
count ++;
ptmp = ptmp->next;
}
w: ptmp = psnval;
if(ptmp) ptmpnext = ptmp->next;
while(ptmp)
{
free(ptmp);
ptmp = ptmpnext;
if(ptmp) ptmpnext = ptmp->next;
}
return bResult;
}
BOOL FOUNDRYCPU_MONITOR(char *server, int port, char *community, CString strIndex,
int rdelay, int timeout, char *cpath, char *szReturn)
{
int s;
struct sockaddr_in serv;
int i = 0, ret = 0;
BOOL bResult = TRUE;
int count = 1;
struct snval *ptmp = NULL;
struct snval *ptmpnext = NULL;
if((ret = MakeSocket(server, port, s, serv)) < 0)
{
if(ret == -1)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_1%>"));//<%IDS_F5_1%>
else if(ret == -2)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_2%>"));//<%IDS_F5_2%>
else
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_3%>"));//<%IDS_F5_3%>
return FALSE;
}
long index_id[32];
int index_id_c = 0;
while(1)
{
i = strIndex.Find('.', 0);
if(i > 0)
index_id[index_id_c++] = atoi(strIndex);
else if(i < 0 && strIndex.GetLength() > 0)
{
index_id[index_id_c++] = atoi(strIndex);
break;
}
else
break;
strIndex.Delete(0, i + 1);
}
for(i = 0;i < index_id_c;i ++)
{
snAgentCpuUtilSlotNum.id[snAgentCpuUtilSlotNum.len ++] = index_id[i];
snAgentCpuUtilCpuId.id[snAgentCpuUtilCpuId.len ++] = index_id[i];
snAgentCpuUtilInterval.id[snAgentCpuUtilInterval.len ++] = index_id[i];
snAgentCpuUtilValue.id[snAgentCpuUtilValue.len ++] = index_id[i];
}
struct oid *poid = NULL, *ptmpoid = NULL;
poid = ptmpoid = &snAgentCpuUtilSlotNum;
ptmpoid->next = &snAgentCpuUtilCpuId;
ptmpoid = ptmpoid->next;
ptmpoid->next = &snAgentCpuUtilInterval;
ptmpoid = ptmpoid->next;
ptmpoid->next = &snAgentCpuUtilValue;
ptmpoid = ptmpoid->next;
struct snval *psnval = NULL;
if((ret = SN_VALUES(s, serv, community, 1, poid, &psnval)) < 0)
{
if(ret == -1)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_4%>"));//<%IDS_F5_4%>
else if(ret == -2)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_5%>"));//<%IDS_F5_5%>
else if(ret == -3)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_6%>"));//<%IDS_F5_6%>
else if(ret == -4)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_7%>"));//<%IDS_F5_7%>
else if(ret == -5)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_8%>"));//<%IDS_F5_8%>
else if(ret == -6)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_9%>"));//<%IDS_F5_9%>
else if(ret == -7)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_10%>"));//<%IDS_F5_10%>
else if(ret == -8)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_11%>"));//<%IDS_F5_11%>
else
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_12%>"));//<%IDS_F5_12%>
bResult = FALSE;
goto w;
}
ptmp = psnval;
ptmpnext = NULL;
while(ptmp)
{
switch(count)
{
case 1:
sprintf(szReturn, "%s=", "snAgentCpuUtilSlotNum");
break;
case 2:
sprintf(szReturn, "%s%s=", szReturn, "snAgentCpuUtilCpuId");
break;
case 3:
sprintf(szReturn, "%s%s=", szReturn, "snAgentCpuUtilInterval");
break;
case 4:
sprintf(szReturn, "%s%s=", szReturn, "snAgentCpuUtilValue");
break;
}
switch(ptmp->sv_type)
{
case ASN1_INT:
sprintf(szReturn, "%s%d$", szReturn, ptmp->sv_val.sv_int);
break;
case ASN1_COUNTER:
case ASN1_GAUGE:
case ASN1_TIMETICKS:
case ASN1_COUNTER64:
case ASN1_UINTEGER32:
sprintf(szReturn, "%s%u$", szReturn, ptmp->sv_val.sv_int);
break;
}
count ++;
ptmp = ptmp->next;
}
w: ptmp = psnval;
if(ptmp) ptmpnext = ptmp->next;
while(ptmp)
{
free(ptmp);
ptmp = ptmpnext;
if(ptmp) ptmpnext = ptmp->next;
}
return bResult;
}
/* The system dynamic memory utilization, in unit of percentage. */
struct oid snAgGblDynMemUtil = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 53}, 11, "", ASN1_GAUGE, ""};
/* The total amount of system dynamic memory, in number of bytes. */
struct oid snAgGblDynMemTotal = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 54}, 11, "", ASN1_INT, ""};
/* The free amount of system dynamic memory, in number of bytes. */
struct oid snAgGblDynMemFree = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 55}, 11, "", ASN1_INT, ""};
BOOL FOUNDRYMEM_MONITOR(char *server, int port, char *community, CString strIndex,
int rdelay, int timeout, char *cpath, char *szReturn)
{
int s;
struct sockaddr_in serv;
int i = 0, ret = 0;
BOOL bResult = TRUE;
int count = 1;
struct snval *ptmp = NULL;
struct snval *ptmpnext = NULL;
if((ret = MakeSocket(server, port, s, serv)) < 0)
{
if(ret == -1)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_1%>"));//<%IDS_F5_1%>
else if(ret == -2)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_2%>"));//<%IDS_F5_2%>
else
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_3%>"));//<%IDS_F5_3%>
return FALSE;
}
long index_id[32];
int index_id_c = 0;
while(1)
{
i = strIndex.Find('.', 0);
if(i > 0)
index_id[index_id_c++] = atoi(strIndex);
else if(i < 0 && strIndex.GetLength() > 0)
{
index_id[index_id_c++] = atoi(strIndex);
break;
}
else
break;
strIndex.Delete(0, i + 1);
}
for(i = 0;i < index_id_c;i ++)
{
snAgGblDynMemUtil.id[snAgGblDynMemUtil.len ++] = index_id[i];
snAgGblDynMemTotal.id[snAgGblDynMemTotal.len ++] = index_id[i];
snAgGblDynMemFree.id[snAgGblDynMemFree.len ++] = index_id[i];
}
struct oid *poid = NULL, *ptmpoid = NULL;
poid = ptmpoid = &snAgGblDynMemUtil;
ptmpoid->next = &snAgGblDynMemTotal;
ptmpoid = ptmpoid->next;
ptmpoid->next = &snAgGblDynMemFree;
ptmpoid = ptmpoid->next;
struct snval *psnval = NULL;
if((ret = SN_VALUES(s, serv, community, 1, poid, &psnval)) < 0)
{
if(ret == -1)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_4%>"));//<%IDS_F5_4%>
else if(ret == -2)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_5%>"));//<%IDS_F5_5%>
else if(ret == -3)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_6%>"));//<%IDS_F5_6%>
else if(ret == -4)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_7%>"));//<%IDS_F5_7%>
else if(ret == -5)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_8%>"));//<%IDS_F5_8%>
else if(ret == -6)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_9%>"));//<%IDS_F5_9%>
else if(ret == -7)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_10%>"));//<%IDS_F5_10%>
else if(ret == -8)
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_11%>"));//<%IDS_F5_11%>
else
sprintf(szReturn, "error=%s", FuncGetStringFromIDS("<%IDS_F5_12%>"));//<%IDS_F5_12%>
bResult = FALSE;
goto w;
}
ptmp = psnval;
ptmpnext = NULL;
while(ptmp)
{
switch(count)
{
case 1:
sprintf(szReturn, "%s=", "snAgGblDynMemUtil");
break;
case 2:
sprintf(szReturn, "%s%s=", szReturn, "snAgGblDynMemTotal");
break;
case 3:
sprintf(szReturn, "%s%s=", szReturn, "snAgGblDynMemFree");
break;
}
switch(ptmp->sv_type)
{
case ASN1_INT:
sprintf(szReturn, "%s%d$", szReturn, ptmp->sv_val.sv_int);
break;
case ASN1_COUNTER:
case ASN1_GAUGE:
case ASN1_TIMETICKS:
case ASN1_COUNTER64:
case ASN1_UINTEGER32:
sprintf(szReturn, "%s%u$", szReturn, ptmp->sv_val.sv_int);
break;
}
count ++;
ptmp = ptmp->next;
}
w: ptmp = psnval;
if(ptmp) ptmpnext = ptmp->next;
while(ptmp)
{
free(ptmp);
ptmp = ptmpnext;
if(ptmp) ptmpnext = ptmp->next;
}
return bResult;
}
// -- image and config file down/up load
struct oid snAgTftpServerIp = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 5}, 11, "", ASN1_IPADDR, ""};
struct oid snAgImgFname = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 6}, 11, "", ASN1_OCTSTR, ""};
struct oid snAgImgLoad = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 7}, 11, "", ASN1_INT, ""};
struct oid snAgCfgFname = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 8}, 11, "", ASN1_OCTSTR, ""};
struct oid snAgCfgLoad = {{0x2b, 6, 1, 4, 1, 1991, 1, 1, 2, 1, 9}, 11, "", ASN1_INT, ""};
enum snAgImgLoadE
{
IMG_NORMAL = 1,
IMG_FLASHPREPAREREADFAILURE = 2,
IMG_FLASHREADERROR = 3,
IMG_FLASHPREPAREWRITEFAILURE = 4,
IMG_FLASHWRITEERROR = 5,
IMG_TFTPTIMEOUTERROR = 6,
IMG_TFTPOUTOFBUFFERSPACE = 7,
IMG_TFTPBUSY = 8,
IMG_TFTPREMOTEOTHERERRORS = 9,
IMG_TFTPREMOTENOFILE = 10,
IMG_TFTPREMOTEBADACCESS = 11,
IMG_TFTPREMOTEDISKFULL = 12,
IMG_TFTPREMOTEBADOPERATION = 13,
IMG_TFTPREMOTEBADID = 14,
IMG_TFTPREMOTEFILEEXISTS = 15,
IMG_TFTPREMOTENOUSER = 16,
IMG_OPERATIONERROR = 17,
IMG_LOADING = 18,
IMG_UPLOADMPPRIMARY = 19,
IMG_DOWNLOADMPPRIMARY = 20,
IMG_UPLOADMPSECONDARY = 21,
IMG_DOWNLOADMPSECONDARY = 22,
IMG_TFTPWRONGFILETYPE = 23,
IMG_DOWNLOADSPPRIMARY = 24,
IMG_DOWNLOADSPSECONDARY = 25
};
enum snAgCfgLoadE
{
CFG_NORMAL = 1,
CFG_FLASHPREPAREREADFAILURE = 2,
CFG_FLASHREADERROR = 3,
CFG_FLASHPREPAREWRITEFAILURE = 4,
CFG_FLASHWRITEERROR = 5,
CFG_TFTPTIMEOUTERROR = 6,
CFG_TFTPOUTOFBUFFERSPACE = 7,
CFG_TFTPBUSY = 8,
CFG_TFTPREMOTEOTHERERRORS = 9,
CFG_TFTPREMOTENOFILE = 10,
CFG_TFTPREMOTEBADACCESS = 11,
CFG_TFTPREMOTEDISKFULL = 12,
CFG_TFTPREMOTEBADOPERATION = 13,
CFG_TFTPREMOTEBADID = 14,
CFG_TFTPREMOTEFILEEXISTS = 15,
CFG_TFTPREMOTENOUSER = 16,
CFG_OPERATIONERROR =17,
CFG_LOADING = 18,
CFG_UPLOADFROMFLASHTOSERVER = 20,
CFG_DOWNLOADTOFLASHFROMSERVER = 21,
CFG_UPLOADFROMDRAMTOSERVER = 22,
CFG_DOWNLOADTODRAMFROMSERVER = 23,
CFG_UPLOADFROMFLASHTONMS = 24,
CFG_DOWNLOADTOFLASHFROMNMS = 25,
CFG_UPLOADFROMDRAMTONMS = 26,
CFG_DOWNLOADTODRAMFROMNMS = 27,
CFG_OPERATIONDONEWITHNMS = 28,
CFG_TFTPWRONGFILETYPE = 29,
CFG_DOWNLOADTODRAMFROMSERVEROVERWRITE = 30
}; | [
"136122085@163.com"
] | 136122085@163.com |
8444ac26fee401b26f6ed672e8d004b4c9b6769e | c6c7778385ab64e5c117134261e3a21c0ac3a193 | /Classes/Server/PathSearchLogic.cpp | 43b57c52b38ddd7ef7fa59bd06c6f6d646071e43 | [] | no_license | TinyUlt/AstarTiledMap | 9097e817d37d1a44afa5cd75eae1802cbe71b516 | 302849f6f8d7115be89f27bb2d1d36fec3a158c9 | refs/heads/master | 2021-01-10T15:18:10.837585 | 2015-05-22T09:45:01 | 2015-05-22T09:45:01 | 36,053,655 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,061 | cpp | #include "PathSearchLogic.h"
#include "StaticValue.h"
#include "MathLogic.h"
std::vector<Vec2> PathSearchLogic::getSearchPath(Vec2 startPoint, Vec2 endPoint)
{
startPoint = resetObjPosition(startPoint);
std::vector<Vec2> _path;
if (endPoint.x<m_mapSize.width && endPoint.y<m_mapSize.height)
{
PathSprite*_sp = NULL;
if ((_sp = m_roadInspectArray[(int)endPoint.x][(int)(endPoint.y)]))
{
_path = calculatePath(startPoint.x, startPoint.y, _sp->m_x, _sp->m_y);
}
else
{
if ((_sp = m_obstaclesInspectArray[(int)endPoint.x][(int)(endPoint.y)]))
{
Vec2 _point =calculatePath(_sp->m_x, _sp->m_y);
if (_point.x !=-1 && _point.y !=-1)
{
_path = calculatePath(startPoint.x, startPoint.y, _point.x, _point.y);
}
}
}
}
return _path;
}
std::vector<Vec2> PathSearchLogic::calculatePath( int startX, int startY, int endX, int endY )
{
clearPath();
std::vector<Vec2> _pathList;
if(m_percision == SEARCH_PATH_NORMAL)
{
//得到开始点的节点
PathSprite* _startNode = m_roadInspectArray[startX][startY];
//得到结束点的节点
PathSprite* _endNode = m_roadInspectArray[endX][endY];
//因为是开始点 把到起始点的距离设为0, F值也为0
_startNode->m_costToSource = 0;
_startNode->m_FValue = 0;
//把已经检测过的点从检测列表中删除
m_roadInspectArray[startX][startY] = NULL;
//把该点放入已经检测过点的列表中
m_haveInspectRoadList.push_back(_startNode);
//然后加入开放列表
m_openList.push_back(_startNode);
PathSprite* _node = NULL;
while (true)
{
//得到离起始点最近的点(如果是第一次执行, 得到的是起点)
_node = getMinPathFormOpenList();
if (!_node)
{
break;
}
//把计算过的点从开放列表中删除
removeAdjacentFromOpenList( _node);
int _x = _node->m_x;
int _y = _node->m_y;
//
if (_x ==endX && _y == endY)
{
break;
}
//检测8个方向的相邻节点是否可以放入开放列表中
PathSprite* _adjacent = NULL;
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x +1, _y);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x , _y -1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x -1, _y);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x , _y+1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray,_x + 1, _y + 1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x +1, _y-1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x -1, _y - 1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x -1, _y+1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
}
while (_node)
{
//把路径点加入到路径列表中
_pathList.insert(_pathList.begin(),Vec2(_node->m_x, _node->m_y) );
_node = _node->m_parent;
}
}
else if(m_percision == SEARCH_PATH_PRECISE)
{
//得到开始点的节点
PathSprite* _endNode= m_roadInspectArray[startX][startY];
//得到结束点的节点
PathSprite* _startNode = m_roadInspectArray[endX][endY];
//因为是开始点 把到起始点的距离设为0, F值也为0
_startNode->m_costToSource = 0;
_startNode->m_FValue = 0;
//把已经检测过的点从检测列表中删除
m_roadInspectArray[endX][endY] = NULL;
//把该点放入已经检测过点的列表中
m_haveInspectRoadList.push_back(_startNode);
//然后加入开放列表
m_openList.push_back(_startNode);
PathSprite* _node = NULL;
while (true)
{
//得到离起始点最近的点(如果是第一次执行, 得到的是起点)
_node = getMinPathFormOpenList();
if (!_node)
{
//不到路径
break;
}
//把计算过的点从开放列表中删除
removeAdjacentFromOpenList( _node);
int _x = _node->m_x;
int _y = _node->m_y;
//
if (_x ==startX && _y == startY)
{
break;
}
//检测8个方向的相邻节点是否可以放入开放列表中
PathSprite* _adjacent = NULL;
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x +1, _y);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x , _y -1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x -1, _y);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x , _y+1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x + 1, _y + 1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x +1, _y-1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x -1, _y - 1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
_adjacent = getAdjacentFromInspectArray( m_roadInspectArray, _x -1, _y+1);
inspectTheAdjacentNodes(_node, _adjacent, _endNode);
}
while (_node)
{
//把路径点加入到路径列表中
_pathList.push_back(Vec2(_node->m_x, _node->m_y) );
_node = _node->m_parent;
}
clearPath();
std::vector<Vec2> _pathListTemp;//路径列表
_pathListTemp.push_back(_pathList[0]);
for (int j = 0; j < _pathList.size(); j++)
{
for (int i = _pathList.size()-1; i > j; i--)
{
if(detectWhetherCanPassBetweenTwoPoints(_pathList[j], _pathList[i]))
{
_pathListTemp.push_back( _pathList[i]);
j = i;
}
}
}
_pathList = _pathListTemp;
}
clearPath();
return _pathList;
}
Vec2 PathSearchLogic::calculatePath(int startX, int startY)//计算点
{
clearPath();
//得到开始点的节点
PathSprite* _startNode = m_obstaclesInspectArray[startX][startY];
//得到结束点的节点
//PathSprite* _endNode = m_obstaclesInspectArray[endX][endY];
//因为是开始点 把到起始点的距离设为0, F值也为0
_startNode->m_costToSource = 0;
_startNode->m_FValue = 0;
//把已经检测过的点从检测列表中删除
m_obstaclesInspectArray[startX][startY] = NULL;
//把该点放入已经检测过点的列表中
m_haveInspectObstaclesList.push_back(_startNode);
//然后加入开放列表
m_openList.push_back(_startNode);
PathSprite* _node = NULL;
Vec2 _endPoint(-1,-1);
while (true)
{
//得到离起始点最近的点(如果是第一次执行, 得到的是起点)
_node = getMinPathFormOpenList();
if (!_node)
{
break;
}
//把计算过的点从开放列表中删除
removeAdjacentFromOpenList( _node);
int _x = _node->m_x;
int _y = _node->m_y;
//
Vec2 _point[4] = {Vec2(_x, _y+1),Vec2(_x, _y-1),Vec2(_x+1, _y),Vec2(_x -1, _y)};
for (int i = 0 ; i < 4; i++)
{
//路径列表中有该点
if (!((int)_point[i].x <0 || (int)_point[i].y <0 || (int)_point[i].x >= m_roadInspectArray.size() ||(int)_point[i].y >= m_roadInspectArray[0].size() ))
{
if(m_roadInspectArray[(int)_point[i].x][(int)_point[i].y])
{
_endPoint = _point[i];
goto B;
}
}
}
//检测8个方向的相邻节点是否可以放入开放列表中
PathSprite* _adjacent = NULL;
_adjacent = getAdjacentFromInspectArray(m_obstaclesInspectArray, _x +1, _y);
inspectTheAdjacentNodes(_node, _adjacent);
_adjacent = getAdjacentFromInspectArray( m_obstaclesInspectArray, _x , _y -1);
inspectTheAdjacentNodes(_node, _adjacent);
_adjacent = getAdjacentFromInspectArray( m_obstaclesInspectArray, _x -1, _y);
inspectTheAdjacentNodes(_node, _adjacent);
_adjacent = getAdjacentFromInspectArray( m_obstaclesInspectArray, _x , _y+1);
inspectTheAdjacentNodes(_node, _adjacent);
_adjacent = getAdjacentFromInspectArray( m_obstaclesInspectArray, _x + 1, _y + 1);
inspectTheAdjacentNodes(_node, _adjacent);
_adjacent = getAdjacentFromInspectArray( m_obstaclesInspectArray, _x +1, _y-1);
inspectTheAdjacentNodes(_node, _adjacent);
_adjacent = getAdjacentFromInspectArray( m_obstaclesInspectArray, _x -1, _y - 1);
inspectTheAdjacentNodes(_node, _adjacent);
_adjacent = getAdjacentFromInspectArray( m_obstaclesInspectArray, _x -1, _y+1);
inspectTheAdjacentNodes(_node, _adjacent);
}
B:
clearPath();
return _endPoint;
}
PathSprite* PathSearchLogic::getMinPathFormOpenList()
{
if (m_openList.size()>0) {
PathSprite* _sp =* m_openList.begin();
for ( std::vector<PathSprite*>::iterator iter = m_openList.begin(); iter != m_openList.end(); iter++)
{
if ((*iter)->m_FValue < _sp->m_FValue)
{
_sp = *iter;
}
}
return _sp;
}
else
{
return NULL;
}
}
PathSprite* PathSearchLogic::getAdjacentFromInspectArray( std::vector< std::vector<PathSprite*>>& InspectArray, int x, int y )
{
if (x >=0 && y >=0 && x < m_mapSize.width && y < m_mapSize.height) {
return InspectArray[x][y];
}
return NULL;
}
void PathSearchLogic::inspectTheAdjacentNodes( PathSprite* node, PathSprite* adjacent, PathSprite* endNode )
{
if (adjacent)
{
float _x = abs(endNode->m_x - adjacent->m_x);
float _y = abs(endNode->m_y - adjacent->m_y);
float F , G, H1, H2, H3;
G = adjacent->m_costToSource = node->m_costToSource + calculateTwoObjDistance(node, adjacent);//获得累计的路程
//三种算法, 感觉H2不错
H1 = _x + _y;
H2 = hypot(_x, _y);
H3 = fmax(_x, _y);
switch (m_algorithm)
{
case SEARCH_PATH_ASTAR:
F = G + H1;
break;
case SEARCH_PATH_DIJKSTRA:
F = G;
break;
case SEARCH_PATH_PRIORITY:
F = H2;
break;
default:
break;
}
adjacent->m_FValue = F;
adjacent->m_parent = node;//设置父节点
m_haveInspectRoadList.push_back(adjacent);
node->m_child = adjacent;//设置子节点
m_roadInspectArray[adjacent->m_x][adjacent->m_y] = NULL;//把检测过的点从检测列表中删除
m_openList.push_back(adjacent);//加入开放列表
}
}
void PathSearchLogic::inspectTheAdjacentNodes( PathSprite* node, PathSprite* adjacent )
{
if (adjacent)
{
float F , G;
G = adjacent->m_costToSource = node->m_costToSource + calculateTwoObjDistance(node, adjacent);//获得累计的路程
//Dijkstra算法
F = G;
adjacent->m_FValue = F;
adjacent->m_parent = node;//设置父节点
m_haveInspectObstaclesList.push_back(adjacent);
node->m_child = adjacent;//设置子节点
m_obstaclesInspectArray[adjacent->m_x][adjacent->m_y] = NULL;//把检测过的点从检测列表中删除
m_openList.push_back(adjacent);//加入开放列表
}
}
float PathSearchLogic::calculateTwoObjDistance( PathSprite* obj1, PathSprite* obj2 )
{
float _x = abs(obj2->m_x - obj1->m_x);
float _y = abs(obj2->m_y - obj1->m_y);
return _x + _y;
}
void PathSearchLogic::clearPath()
{
resetInspectArray();
m_openList.clear();
m_haveInspectRoadList.clear();
m_haveInspectObstaclesList.clear();
}
void PathSearchLogic::resetInspectArray()
{
for (std::vector<PathSprite*>::iterator iter = m_haveInspectRoadList.begin(); iter != m_haveInspectRoadList.end(); iter++)
{
(*iter)->m_costToSource = 0;
(*iter)->m_FValue = 0;
(*iter)->m_parent = NULL;
(*iter)->m_child = NULL;
m_roadInspectArray[(*iter)->m_x][(*iter)->m_y] = (*iter);
}
for (std::vector<PathSprite*>::iterator iter = m_haveInspectObstaclesList.begin(); iter != m_haveInspectObstaclesList.end(); iter++)
{
(*iter)->m_costToSource = 0;
(*iter)->m_FValue = 0;
(*iter)->m_parent = NULL;
(*iter)->m_child = NULL;
m_obstaclesInspectArray[(*iter)->m_x][(*iter)->m_y] = (*iter);
}
}
bool PathSearchLogic::removeAdjacentFromOpenList( PathSprite* sprite )
{
if (!sprite) {
return false;
}
for ( std::vector<PathSprite*>::iterator iter = m_openList.begin(); iter != m_openList.end(); iter++)
{
if (*iter == sprite)
{
m_openList.erase(iter);
return true;
}
}
return false;
}
bool PathSearchLogic::detectWhetherCanPassBetweenTwoPoints( Vec2 p1, Vec2 p2 )
{
float _maxX = p1.x>p2.x?p1.x:p2.x;
float _maxY = p1.y>p2.y?p1.y:p2.y;
float _minX = p1.x<p2.x?p1.x:p2.x;
float _minY = p1.y<p2.y?p1.y:p2.y;
if (p1.x == p2.x)
{
if (_maxY - _minY >1)
{
return false;
}
float _x = p1.x;
for (int _y = _minY; _y <=_maxY; _y++)
{
PathSprite*_sp = m_roadInspectArray[(int)_x][(int)(_y)];
if (!_sp)
{
return false;
}
}
}
else if (p1.y == p2.y)
{
if (_maxX - _minX > 1)
{
return false;
}
float _y = p1.y;
for (int _x = _minX; _x <=_maxX; _x++ )
{
PathSprite*_sp = m_roadInspectArray[(int)_x][(int)(_y)];
if (!_sp)
{
return false;
}
}
}
else
{
for (int _y = _minY; _y <= _maxY; _y++)
{
for (int _x = _minX; _x <= _maxX; _x++)
{
float _length = MathLogic::linearEquationWithOneUnknown_solveShortLenghtRequiredPoint(p1, p2, Vec2(_x, _y));
float _maxLength = MathLogic::calculateLengthRequiredTwoPoint(Vec2(0,0), Vec2(0.5,0.5));
if (_length < _maxLength)
{
PathSprite*_sp = m_roadInspectArray[(int)_x][(int)(_y)];
if (!_sp)
{
return false;
}
}
}
}
}
return true;
}
Vec2 PathSearchLogic::resetObjPosition(Vec2 point )
{
PathSprite* _sp = m_roadInspectArray[point.x][point.y];
if (_sp)
{
return point;
}
else
{
Vec2 _PArray[4] = {point + Vec2(0, -1),point + Vec2(0, 1), point + Vec2(-1, 0), point + Vec2(1, 0)};
for (int i = 0 ; i < 4 ; i++)
{
PathSprite* _up = m_roadInspectArray[_PArray[i].x][_PArray[i].y];
if (_up)
{
return _PArray[i];
}
}
}
return point;
} | [
"TinyUlt@icloud.com"
] | TinyUlt@icloud.com |
14e7ebcc7fd7d43bfb8b265374b47ce3cf0dd0f1 | 4f8dec85ac01026a57450c73dd31cbe543624dba | /GifPlugin/Plugins/GIF_recorder/Source/GIF_recorder/Public/GIF_recorder.h | 27bdee77df219301b6aee7192db9b84bf434841e | [] | no_license | raycode/GifRecorder | 5bfe48e723061a18e743dfce5352a842305b1f76 | b2fbbba96db47dc689c61af4ad55bef4b70d9eb3 | refs/heads/master | 2023-03-15T12:12:11.858843 | 2019-07-09T03:52:17 | 2019-07-09T03:52:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,602 | h | // Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include <vector>
#include "Runtime/SlateCore/Public/Types/SlateEnums.h"
#include "Modules/ModuleManager.h"
class FToolBarBuilder;
class FMenuBuilder;
class FReply;
class FUICommandList;
class SButton;
class UMaterial;
struct FSlateImageBrush;
struct FSlateDynamicImageBrush;
struct FSlateBrush;
class UMaterialInstanceDynamic;
class GIF_frameCapture;
class FDelegateHandle;
class UTexture2D;
class SImage;
class SDockTab;
class FGIF_recorderModule : public IModuleInterface
{
public:
/** IModuleInterface implementation */
virtual void StartupModule() override;
virtual void ShutdownModule() override;
/** This function will be bound to Command (by default it will bring up plugin window) */
void PluginButtonClicked();
void PluginRecordButtonClicked();
/** Seb comment: Function for what to do when pressing the save button**/
FReply SaveButtonClicked();
FReply SelectPathButtonClicked();
void OnViewportTabClosed(TSharedRef<SDockTab> ClosedTab);
private:
/** Seb comment: Function for what to do when the value was changed**/
void StartTimeChanged(int32 NewNumber);
TOptional<int32> HandleStartTimeValue() const;
void EndTimeChanged(int32 NewNumber);
TOptional<int32> HandleEndTimeValue() const;
TOptional<int32> HandleMaxValues() const;
const FSlateBrush* GetMainScreenBrush() const;
void OnPathTextCommitted(const FText& InText, ETextCommit::Type InCommitType);
FText GetPathText() const;
void AddToolbarExtension(FToolBarBuilder& Builder);
void AddMenuExtension(FMenuBuilder& Builder);
void AddRecorderToolbarExtension(FToolBarBuilder& Builder);
/** Seb comment: Functions for setting the styles**/
void CreateSaveButtonStyle();
void CreateMainScreenStyle();
bool Tick(float DeltaTime);
TSharedRef<class SDockTab> OnSpawnPluginTab(const class FSpawnTabArgs& SpawnTabArgs);
private:
TSharedPtr<class FUICommandList> PluginCommands;
TSharedPtr<class FUICommandList> RecordCommands;
TSharedPtr<SButton> SaveButton;
TSharedPtr<SImage> MainScreenImage;
TSharedPtr<FSlateDynamicImageBrush> SaveButtonBrush;
TSharedPtr<FSlateImageBrush> MainScreenBrush;
FDelegateHandle TickDelegateHandle;
TArray<FSlateImageBrush*> brushArray;
int32 StartTime;
int32 EndTime;
int32 MaxValue;
float FramesPerSecond;
float FrameTimer;
TSharedPtr<UTexture2D> test1;
TSharedPtr<UTexture2D> test2;
TSharedPtr<GIF_frameCapture> recorder;
bool isRecording = false;
bool WindowIsOpen = false;
int currentFrame = 0;
int FrameCounter = 0;
FText SavePath;
};
| [
"sebbetengdahl@hotmail.com"
] | sebbetengdahl@hotmail.com |
e2e41a0f7fc644e8608c19100748fd8aff0a16ef | e1128261b921c339ecda199bfcb8f0fac04e6cc7 | /src/openloco/ui/scrollview.h | f7e188d327ed2a61f23ec16398fb9a91eed62c25 | [
"MIT"
] | permissive | marijnvdwerf/wissel | 40eb7c1cfc884b457691bd3d68a8c6ccbcad1170 | 33da272b18b38e2e9e55b08a79a0d539a6790c0d | refs/heads/master | 2020-04-01T12:02:41.039218 | 2019-02-08T21:09:28 | 2019-02-08T21:09:28 | 153,188,647 | 3 | 1 | MIT | 2019-02-17T15:52:30 | 2018-10-15T22:16:53 | C++ | UTF-8 | C++ | false | false | 865 | h | #include "../interop/interop.hpp"
#include "../window.h"
using namespace openloco::interop;
namespace openloco::ui::scrollview
{
enum class scroll_part
{
none = -1,
view = 0,
hscrollbar_button_left = 1,
hscrollbar_button_right = 2,
hscrollbar_track_left = 3,
hscrollbar_track_right = 4,
hscrollbar_thumb = 5,
vscrollbar_button_top = 6,
vscrollbar_button_bottom = 7,
vscrollbar_track_top = 8,
vscrollbar_track_bottom = 9,
vscrollbar_thumb = 10,
};
void get_part(
ui::window* window,
ui::widget_t* widget,
int16_t x,
int16_t y,
int16_t* output_x,
int16_t* output_y,
scroll_part* output_scroll_area,
int32_t* scroll_id);
void update_thumbs(window* window, widget_index widgetIndex);
}
| [
"marijn.vanderwerf@gmail.com"
] | marijn.vanderwerf@gmail.com |
39c6200fabc2ee8af7e799cdb42f740bb45f8de1 | 99224ad2b09267051f95e87ad9e17f9bea43c007 | /function/FunctionAXPY.cpp | 01c9271bcc59022cfbb19e98dc5d18702d76ebcf | [] | no_license | thejourneyofman/WinDolfin | bcf7bf4e7c78a7c443a3f24259527afb98ae9bbd | ffae925d449957f3d1ede14070bb9bb81ca7e97a | refs/heads/main | 2023-02-15T12:27:26.648397 | 2021-01-03T18:27:43 | 2021-01-03T18:27:43 | 325,487,994 | 1 | 0 | null | 2021-01-03T18:33:35 | 2020-12-30T07:44:37 | C++ | UTF-8 | C++ | false | false | 6,072 | cpp | // Copyright (C) 2013 Johan Hake
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
//
// First added: 2013-02-11
// Last changed: 2013-02-15
#include <log/log.h>
#include "Function.h"
#include "FunctionSpace.h"
#include "FunctionAXPY.h"
using namespace dolfin;
//-----------------------------------------------------------------------------
FunctionAXPY::FunctionAXPY(std::shared_ptr<const Function> func, double scalar)
: _pairs()
{
dolfin_assert(func);
_pairs.push_back(std::make_pair(scalar, func));
}
//-----------------------------------------------------------------------------
FunctionAXPY::FunctionAXPY(const FunctionAXPY& axpy, double scalar) : _pairs()
{
_register(axpy, scalar);
}
//-----------------------------------------------------------------------------
FunctionAXPY::FunctionAXPY(std::shared_ptr<const Function> func0,
std::shared_ptr<const Function> func1,
Direction direction) : _pairs()
{
dolfin_assert(func0);
dolfin_assert(func1);
dolfin_assert(func1->function_space());
if (!func0->in(*func1->function_space()))
{
dolfin_error("FunctionAXPY.cpp",
"Construct FunctionAXPY",
"Expected Functions to be in the same FunctionSpace");
}
const double scale0 = static_cast<int>(direction) % 2 == 0 ? 1.0 : -1.0;
_pairs.push_back(std::make_pair(scale0, func0));
const double scale1 = static_cast<int>(direction) < 2 ? 1.0 : -1.0;
_pairs.push_back(std::make_pair(scale1, func1));
}
//-----------------------------------------------------------------------------
FunctionAXPY::FunctionAXPY(const FunctionAXPY& axpy,
std::shared_ptr<const Function> func,
Direction direction) : _pairs()
{
dolfin_assert(func);
dolfin_assert(func->function_space());
_register(axpy, static_cast<int>(direction) % 2 == 0 ? 1.0 : -1.0);
if (_pairs.size()>0 && !_pairs[0].second->in(*func->function_space()))
{
dolfin_error("FunctionAXPY.cpp",
"Construct FunctionAXPY",
"Expected Functions to have the same FunctionSpace");
}
const double scale = static_cast<int>(direction) < 2 ? 1.0 : -1.0;
_pairs.push_back(std::make_pair(scale, func));
}
//-----------------------------------------------------------------------------
FunctionAXPY::FunctionAXPY(const FunctionAXPY& axpy0,
const FunctionAXPY& axpy1,
Direction direction) : _pairs()
{
_register(axpy0, static_cast<int>(direction) % 2 == 0 ? 1.0 : -1.0);
_register(axpy1, static_cast<int>(direction) < 2 ? 1.0 : -1.0);
}
//-----------------------------------------------------------------------------
FunctionAXPY::FunctionAXPY(const FunctionAXPY& axpy) : _pairs(axpy._pairs)
{
// Do nothing
}
//-----------------------------------------------------------------------------
FunctionAXPY::FunctionAXPY(
std::vector<std::pair<double, std::shared_ptr<const Function>>> pairs)
: _pairs(pairs)
{
// Do nothing
}
//-----------------------------------------------------------------------------
FunctionAXPY::~FunctionAXPY()
{
// Do nothing
}
//-----------------------------------------------------------------------------
FunctionAXPY FunctionAXPY::operator+(std::shared_ptr<const Function> func) const
{
return FunctionAXPY(*this, func, Direction::ADD_ADD);
}
//-----------------------------------------------------------------------------
FunctionAXPY FunctionAXPY::operator+(const FunctionAXPY& axpy) const
{
return FunctionAXPY(*this, axpy, Direction::ADD_ADD);
}
//-----------------------------------------------------------------------------
FunctionAXPY FunctionAXPY::operator-(std::shared_ptr<const Function> func) const
{
return FunctionAXPY(*this, func, Direction::ADD_SUB);
}
//-----------------------------------------------------------------------------
FunctionAXPY FunctionAXPY::operator-(const FunctionAXPY& axpy) const
{
return FunctionAXPY(*this, axpy, Direction::ADD_SUB);
}
//-----------------------------------------------------------------------------
const std::vector<std::pair<double, std::shared_ptr<const Function>>>&
FunctionAXPY::pairs() const
{
return _pairs;
}
//-----------------------------------------------------------------------------
void FunctionAXPY::_register(const FunctionAXPY& axpy, double scale)
{
if (_pairs.size() > 0 && axpy._pairs.size() > 0
&& _pairs[0].second && axpy._pairs[0].second // nullptr checks
&& axpy._pairs[0].second->function_space() // nullptr checks
&& !_pairs[0].second->in(*axpy._pairs[0].second->function_space()))
{
dolfin_error("FunctionAXPY.cpp",
"Construct FunctionAXPY",
"Expected Functions to have the same FunctionSpace");
}
for (auto it = axpy.pairs().begin(); it != axpy.pairs().end(); it++)
{
dolfin_assert(it->second);
_pairs.push_back(std::make_pair(it->first*scale, it->second));
}
}
//-----------------------------------------------------------------------------
FunctionAXPY FunctionAXPY::operator*(double scale) const
{
return FunctionAXPY(*this, scale);
}
//-----------------------------------------------------------------------------
FunctionAXPY FunctionAXPY::operator/(double scale) const
{
return FunctionAXPY(*this, 1.0/scale);
}
//-----------------------------------------------------------------------------
| [
"jo.chou.cc@gmail.com"
] | jo.chou.cc@gmail.com |
d917645ea442dfdbfcfdc1b15ce184b7da3be07c | 2a0e2c50daf0aea7a5aebfd8d4b2d495ff059ff6 | /ShiningRoadProject/SourceCodo/PartsWeapon.cpp | 75928c43b977207873ef84d4aabd8c1c60d990b6 | [] | no_license | Tone2387/ShiningRoadProject | 75a8a86ecabf536f1ecad7db63fe0f8663061c9a | 82d16c89278a3910d92205332dfdaae0c099d474 | refs/heads/master | 2021-07-09T15:44:15.877596 | 2019-01-23T14:54:14 | 2019-01-23T14:54:14 | 134,210,698 | 0 | 0 | null | 2019-01-25T15:04:06 | 2018-05-21T03:01:18 | RPC | SHIFT_JIS | C++ | false | false | 1,253 | cpp | #include "PartsWeapon.h"
clsPARTS_WEAPON::clsPARTS_WEAPON()
{
}
clsPARTS_WEAPON::~clsPARTS_WEAPON()
{
}
//作成時.
void clsPARTS_WEAPON::InitProduct()
{
}
//毎フレーム.
void clsPARTS_WEAPON::UpdateProduct()
{
}
//直前のフレームのボーンの座標を持ってくる.
D3DXVECTOR3 clsPARTS_WEAPON::GetBonePosPreviosFrame(
const int enBoneName,
int iVecNum ) const
{
switch( enBoneName )
{
case enWEAPON_BONE_POSITIONS_MUZZLE_ROOT:
return m_BonePositions.vMuzzleRoot;
case enWEAPON_BONE_POSITIONS_MUZZLE_END:
return m_BonePositions.vMuzzleEnd;
case enWEAPON_BONE_POSITIONS_CARTRIDGE_INJECTION:
return m_BonePositions.vCartridgeInjection;
default:
assert( !"不正な値" );
GetBonePosPreviosFrame( enBoneName, iVecNum );
break;
}
D3DXVECTOR3 vReturnPos = { 0.0f, 0.0f, 0.0f };
return vReturnPos;
}
//↑で使うためにボーン座標を記録する( Renderの直後に使う ).
void clsPARTS_WEAPON::UpdateBonePosPreviosFrame()
{
m_BonePositions.vMuzzleRoot = this->GetBonePos( sBONE_NAME_WEAPON_MUZZLE_ROOT );
m_BonePositions.vMuzzleEnd = this->GetBonePos( sBONE_NAME_WEAPON_MUZZLE_END );
m_BonePositions.vCartridgeInjection = this->GetBonePos( sBONE_NAME_WEAPON_CARTRIDGE_INJECTION );
}
| [
"34734345+Tone2387@users.noreply.github.com"
] | 34734345+Tone2387@users.noreply.github.com |
8c057f288c90046c8ac5297bc6e3f228752c4b33 | dbe617f081a09df8698b70ec08af25dd827b3f2d | /algorithm/topology/CoveringSpace/CoveringMesh.h | f0de9c08a3ebb8273b0fcde9dd9e6862bf4a3087 | [] | no_license | kabukunz/meshlib | 827052ff3c11fea772deb85eb26ce934be79d12b | 329d405dd210b2dde05cfe480a79b9c15ac01ffe | refs/heads/main | 2023-06-16T00:44:54.397676 | 2021-07-09T10:31:15 | 2021-07-09T10:31:15 | 384,402,573 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,421 | h | #ifndef _COVERING_MESH_H_
#define _COVERING_MESH_H_
#include <math.h>
#include <assert.h>
#include <iostream>
#include <fstream>
#include <list>
#include <vector>
#include <map>
#include "Mobius/Mobius.h"
#include "Mesh/BaseMesh.h"
#include "Mesh/Vertex.h"
#include "Mesh/HalfEdge.h"
#include "Mesh/Edge.h"
#include "Mesh/Face.h"
#include "mesh/iterators.h"
#include "mesh/boundary.h"
#include "Parser/parser.h"
#include "Parser/traits_io.h"
#include "Geometry/Line2D.h"
namespace MeshLib{
template<typename T>
void __swap( T & a, T & b ) { T c = a; a = b; b = c; };
namespace Topology
{
template<typename V, typename E, typename F, typename H, typename M>
class CoveringSpace
{
public:
class CFace
{
public:
CFace(){};
~CFace(){};
F * & base() { return m_base; };
CHalfEdge * & halfedge() { return m_halfedge; };
protected:
F * m_base;
CHalfEdge * m_halfedge;
};
class CEdge
{
public:
CEdge()
{
for( int i = 0; i < 2; i ++ )
{
m_halfedges[i] = NULL;
}
};
~CEdge(){};
E * & base() { return m_base; };
CHalfEdge * & halfedge( int k ) { return m_halfedges[k]; };
double & length() { return m_length; };
protected:
E * m_base;
CHalfEdge * m_halfedges[2];
double m_length;
};
class CHalfEdge
{
public:
CHalfEdge(){ m_edge = NULL; m_face = NULL; m_next = NULL; m_prev = NULL; m_vert = NULL; };
~CHalfEdge(){};
H *& base(){ return m_base; };
CHalfEdge *& prev(){ return m_prev; };
CHalfEdge *& next(){ return m_next; };
CEdge *& edge(){ return m_edge; };
CFace *& face(){ return m_face; };
CVertex *& target(){ return m_vert; };
CVertex *& source(){ return m_prev->target(); };
CHalfEdge * dual()
{
if( m_edge == NULL ) return NULL;
return (m_edge->halfedge(0) != this )? m_edge->halfedge(0): m_edge->halfedge(1);
};
double & angle() { return m_angle; };
protected:
CVertex * m_vert;
CHalfEdge * m_prev;
CHalfEdge * m_next;
CFace * m_face;
CEdge * m_edge;
H * m_base;
double m_angle;
};
class CVertex
{
public:
CVertex(){};
~CVertex(){};
int & id(){ return m_id; };
V *& base(){ return m_base; };
CHalfEdge * & halfeddge() { return m_halfedge; };
std::complex<double> & uv() { return m_uv; };
protected:
V * m_base;
int m_id;
CHalfEdge * m_halfedge;
std::complex<double> m_uv;
};
//hyperbolic cosine law
class hyperbolic_cosine_law
{
public:
double operator()( double a, double b, double c )
{
return acos( (cosh(a) * cosh(b)-cosh(c) )/( sinh(a)*sinh(b)) );
};
};
class compareEdgeMeshPair
{
public:
bool operator()( std::pair<E*,M*> e1, std::pair<E*,M*> e2 )
{
M * pMesh = e1.second;
E * pE1 = e1.first;
E * pE2 = e2.first;
V * s1 = pMesh->edgeVertex1( pE1 );
V * t1 = pMesh->edgeVertex2( pE1 );
int sf1 = (s1->father()< t1->father() )? s1->father():t1->father();
int tf1 = (s1->father()< t1->father() )? t1->father():s1->father();
V * s2 = pMesh->edgeVertex1( pE2 );
V * t2 = pMesh->edgeVertex2( pE2 );
int sf2 = (s2->father()< t2->father() )? s2->father():t2->father();
int tf2 = (s2->father()< t2->father() )? t2->father():s2->father();
if( sf1 < sf2 ) return true;
if( sf1 > sf2 ) return false;
return tf1 < tf2;
}
};
class compareHalfEdge
{
public:
bool operator()(CHalfEdge * pH1, CHalfEdge * pH2)
{
CVertex * s1 = pH1->source();
CVertex * t1 = pH1->target();
int sid1 = (s1->base()->id() < t1->base()->id())?s1->base()->id():t1->base()->id();
int tid1 = (s1->base()->id() > t1->base()->id())?s1->base()->id():t1->base()->id();
CVertex * s2 = pH2->source();
CVertex * t2 = pH2->target();
int sid2 = (s2->base()->id() < t2->base()->id())?s2->base()->id():t2->base()->id();
int tid2 = (s2->base()->id() > t2->base()->id())?s2->base()->id():t2->base()->id();
if( sid1 < sid2 ) return true;
if( sid1 > sid2 ) return false;
return tid1 < tid2;
}
};
class CNeighborhood
{
public:
CNeighborhood( V * pV, M * pM );
~CNeighborhood();
std::vector<CFace*> & faces() { return m_faces; };
std::vector<CVertex*> & vertices(){ return m_verts; };
void operator*=( CMobius & mob );
CVertex *& center() { return m_center; };
void _embed();
CFace* createFace( std::vector<CVertex*> & verts )
{
CFace * pF = new CFace;
assert( pF );
m_faces.push_back(pF);
std::vector<CHalfEdge*> hes;
for( size_t i = 0; i < 3; i ++ )
{
CHalfEdge * pH = new CHalfEdge;
assert( pH );
m_halfedges.push_back( pH );
pH->target() = verts[i];
pH->face() = pF;
hes.push_back( pH );
}
for( size_t i = 0; i < 3; i ++ )
{
hes[i]->next() = hes[(i+1)%3];
hes[i]->prev() = hes[(i+2)%3];
}
pF->halfedge() = hes[0];
return pF;
};
protected:
CVertex * m_center;
std::vector<CVertex*> m_verts;
std::vector<CFace*> m_faces;
std::list<CHalfEdge*> m_halfedges;
std::list<CEdge*> m_edges;
M* m_pMesh;
};
class compareFaceInNeighborhood
{
public:
bool operator()(std::pair<CFace*,CNeighborhood*> pF1, std::pair<CFace*,CNeighborhood*> pF2)
{
return pF1.first->base()->id() < pF2.first->base()->id();
}
};
class CFundamentalDomain
{
public:
CFundamentalDomain( M * pM, M * pD );
~CFundamentalDomain(){};
F* dual_face( F * pF ) { return m_face_map[pF]; };
E* dual_edge( E * pE ) { return m_edge_map[pE]; };
V* base() { return m_base; };
V* origin() { return m_origin; };
protected:
M * m_pMesh;
M * m_pDomain;
//find covering face for m_pDomain, m_pMesh
std::map<F*,F*> m_face_map;
std::map<E*,E*> m_edge_map;
V * m_base; //base point on the closed mesh
V * m_origin; //origin point on the domain
protected:
//construct the face map
void _construct_face_map();
//construct the edge map
void _construct_edge_map();
//locate base
void _locate_base();
};
class CLiftedPath
{
public:
CLiftedPath( M* pM, M * pD, const char * input );
~CLiftedPath();
void _embed( CFundamentalDomain * pD );
//output the path to a mesh file
void _output( const char * output_file );
CMobius _fuchsian_transformation();
void _straighten( CFundamentalDomain * pD, const char * name, const char * plane_name );
void _ray( CFundamentalDomain * pD, CPoint2 S, CPoint2 T, std::vector<std::pair<CPoint,CPoint2> > & pts );
protected:
std::vector<CNeighborhood*> m_neighborhoods;
//find the overlapping faces, each pair, first face is in pN1, 2nd face is in pN2
void _overlap( CNeighborhood * pN1, CNeighborhood * pN2, std::vector<std::pair<CFace*,CFace*>> & pairs );
CMobius _transform( CFace * pF0, CFace * pF1 );
CMobius MT( std::complex<double> za, std::complex<double> zb );
CMobius _transformation( std::complex<double> A, std::complex<double> B, std::complex<double> IA, std::complex<double> IB );
//if the line intersecting the edge, true - intersect, false- non-intersect
//q - intersection point, lambda is the ratio in the line segment from pS to pT
bool _intersect( CPoint2 pS, CPoint2 pT, E * pE, CPoint2 & q, double & lambda );
//funchsian transform the whole fundamental domain
void _Fuchsian_Transform( E* eS, E * eT );
M * m_pMesh;
M * m_pDomain;
};
};
#include "FundamentalDomain.hpp"
#include "Neighborhood.hpp"
#include "LiftedPath.hpp"
} //namespace Topology
} //namespace MeshLib
#endif
| [
"kabukunz@gmail.com"
] | kabukunz@gmail.com |
b8855d7aeba9691fe44f56a4895d6c2a07eb5721 | 04af3b839eb8fde7a1662fc9e625864d9673ec05 | /core/src/BoundingBoxes.cpp | 78f2594d978c82d77577784f0492de9ed5859522 | [] | no_license | gralkapk/megamol_pub_backup | d7a53adf53011f9e8b9b2069f908db0413f6baae | 7b405a4003d578adbb70cb6a29ffcc8d01e0fca1 | refs/heads/master | 2021-06-21T17:58:40.648674 | 2017-08-03T10:32:54 | 2017-08-03T10:32:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,753 | cpp | /*
* BoundingBoxes.cpp
*
* Copyright (C) 2009 by VISUS (Universitaet Stuttgart)
* Alle Rechte vorbehalten.
*/
#include "stdafx.h"
#include "mmcore/BoundingBoxes.h"
#include "vislib/math/mathfunctions.h"
using namespace megamol::core;
/*
* BoundingBoxes::BoundingBoxes
*/
BoundingBoxes::BoundingBoxes(void) : clipBox(), clipBoxValid(false), osBBox(),
osBBoxValid(false), osClipBox(), osClipBoxValid(false), osScale(0.0),
wsBBox(), wsBBoxValid(false), wsClipBox(), wsClipBoxValid(false) {
// intentionally empty
}
/*
* BoundingBoxes::BoundingBoxes
*/
BoundingBoxes::BoundingBoxes(const BoundingBoxes& src) : clipBox(src.clipBox),
clipBoxValid(src.clipBoxValid), osBBox(src.osBBox),
osBBoxValid(src.osBBoxValid), osClipBox(src.osClipBox),
osClipBoxValid(src.osClipBoxValid), osScale(src.osScale),
wsBBox(src.wsBBox), wsBBoxValid(src.wsBBoxValid),
wsClipBox(src.wsClipBox), wsClipBoxValid(src.wsClipBoxValid) {
// intentionally empty
}
/*
* BoundingBoxes::~BoundingBoxes
*/
BoundingBoxes::~BoundingBoxes(void) {
// intentionally empty
}
/*
* BoundingBoxes::MakeScaledWorld
*/
void BoundingBoxes::MakeScaledWorld(float f) {
this->clipBoxValid = false;
this->wsBBox = this->osBBox;
this->wsBBox *= f;
this->wsBBoxValid = this->osBBoxValid;
this->wsClipBox = this->osClipBox;
this->wsClipBox *= f;
this->wsClipBoxValid = this->osClipBoxValid;
}
/*
* BoundingBoxes::operator==
*/
bool BoundingBoxes::operator==(const BoundingBoxes& rhs) const {
// don't have to check clip box, because it's evaluated lazy
return (!this->osBBoxValid || (this->osBBox == rhs.osBBox))
&& (this->osBBoxValid == rhs.osBBoxValid)
&& (!this->osClipBoxValid || (this->osClipBox == rhs.osClipBox))
&& (this->osClipBoxValid == rhs.osClipBoxValid)
&& vislib::math::IsEqual(this->osScale, rhs.osScale)
&& (!this->wsBBoxValid || (this->wsBBox == rhs.wsBBox))
&& (this->wsBBoxValid == rhs.wsBBoxValid)
&& (!this->wsClipBoxValid || (this->wsClipBox == rhs.wsClipBox))
&& (this->wsClipBoxValid == rhs.wsClipBoxValid);
}
/*
* BoundingBoxes::operator=
*/
BoundingBoxes& BoundingBoxes::operator=(const BoundingBoxes& rhs) {
this->clipBox = rhs.clipBox;
this->clipBoxValid = rhs.clipBoxValid;
this->osBBox = rhs.osBBox;
this->osBBoxValid = rhs.osBBoxValid;
this->osClipBox = rhs.osClipBox;
this->osClipBoxValid = rhs.osClipBoxValid;
this->osScale = rhs.osScale;
this->wsBBox = rhs.wsBBox;
this->wsBBoxValid = rhs.wsBBoxValid;
this->wsClipBox = rhs.wsClipBox;
this->wsClipBoxValid = rhs.wsClipBoxValid;
return *this;
}
/*
* BoundingBoxes::calcClipBox
*/
void BoundingBoxes::calcClipBox(void) const {
if (this->wsClipBoxValid) {
this->clipBox = this->wsClipBox;
if (this->wsBBoxValid) {
this->clipBox.Union(this->wsBBox);
}
} else {
if (this->wsBBoxValid) {
this->clipBox = this->wsBBox;
} else {
if (this->osClipBoxValid) {
this->clipBox = this->osClipBox;
if (this->osBBoxValid) {
this->clipBox.Union(this->osBBox);
}
} else {
if (this->osBBoxValid) {
this->clipBox = this->osBBox;
} else {
// if everything fails ...
this->clipBox.Set(-1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f);
}
}
}
}
this->clipBoxValid = true;
}
| [
"grottel@77d55b08-817d-0410-979b-1fec1beb8c2e"
] | grottel@77d55b08-817d-0410-979b-1fec1beb8c2e |
b7e0005808a90ae2405c012a19758cf3304167d0 | 7e6afb4986a53c420d40a2039240f8c5ed3f9549 | /libs/math/src/MatrixVectorBase_instantiate_CVectorDynamic.cpp | cb20e8152c47c05661a72a1ff148f1e6aebef743 | [
"BSD-3-Clause"
] | permissive | MRPT/mrpt | 9ea3c39a76de78eacaca61a10e7e96646647a6da | 34077ec74a90b593b587f2057d3280ea520a3609 | refs/heads/develop | 2023-08-17T23:37:29.722496 | 2023-08-17T15:39:54 | 2023-08-17T15:39:54 | 13,708,826 | 1,695 | 646 | BSD-3-Clause | 2023-09-12T22:02:53 | 2013-10-19T21:09:23 | C++ | UTF-8 | C++ | false | false | 1,256 | cpp | /* +------------------------------------------------------------------------+
| Mobile Robot Programming Toolkit (MRPT) |
| https://www.mrpt.org/ |
| |
| Copyright (c) 2005-2023, Individual contributors, see AUTHORS file |
| See: https://www.mrpt.org/Authors - All rights reserved. |
| Released under BSD License. See: https://www.mrpt.org/License |
+------------------------------------------------------------------------+ */
#include "math-precomp.h" // Precompiled headers
//
#include <mrpt/math/CVectorDynamic.h>
#include <Eigen/Dense>
#include "MatrixVectorBase_impl.h"
using namespace mrpt::math;
template <typename T>
template <typename T2>
CVectorDynamic<T2> CVectorDynamic<T>::cast() const
{
CVectorDynamic<T2> r(size());
r.asEigen() = asEigen().template cast<T2>();
return r;
}
// Explicit instantiation of "MatrixVectorBase_impl.h" methods:
#define DO_VECDYN_INSTANTIATION(T_) \
template class mrpt::math::MatrixVectorBase<T_, CVectorDynamic<T_>>;
DO_VECDYN_INSTANTIATION(float)
DO_VECDYN_INSTANTIATION(double)
| [
"joseluisblancoc@gmail.com"
] | joseluisblancoc@gmail.com |
ef379a16a6938c3bd192ab93e5c1de078516d3e4 | 89cf7930fc4d4e448afbec07fa226967bcea1b01 | /DLL430_v3/src/TI/DLL430/EM/EemRegisters/EemRegisterAccess.cpp | 582edd220f9144789088b445980d093eb6bc0d67 | [] | no_license | jck/mspds | 4b384de769a0fbd6e8cd16207e72b9b9fb67cfd3 | d8d099e7274db434475f99723bb2d234f2ff6dfb | refs/heads/master | 2020-03-30T03:08:17.944317 | 2015-01-15T06:29:33 | 2015-01-15T06:29:33 | 29,283,923 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,724 | cpp | /*
* EemRegisterAccess.cpp
*
* Handles access to eem registers through EemMemoryAccess
*
* Copyright (C) 2007 - 2011 Texas Instruments Incorporated - http://www.ti.com/
*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <pch.h>
#include "EemRegisterAccess.h"
#include "EemMemoryAccess.h"
#include "../Exceptions/Exceptions.h"
namespace
{
static TI::DLL430::EemMemoryAccess* ema_ = 0;
struct CacheEntry
{
CacheEntry() : value(0), valid(false) {}
uint32_t value;
bool valid;
};
std::vector<CacheEntry> cache;
}
void TI::DLL430::setEemRegisterAccess(EemMemoryAccess* ema)
{
resetEemRegisterCache();
ema_ = ema;
}
void TI::DLL430::resetEemRegisterCache()
{
cache.clear();
//0xBE currently largest used address, no odd addresses
cache.resize((0xBE / 2) + 1);
}
void TI::DLL430::rewriteEemRegisters()
{
if (!ema_)
throw EM_RegisterWriteException();
for (size_t i = 0; i < cache.size(); ++i)
{
if (cache[i].valid)
{
if (!ema_->writeEemRegister((EemRegister)(i*2), cache[i].value))
throw EM_RegisterWriteException();
}
}
if (!ema_->sync())
throw EM_RegisterWriteException();
}
void TI::DLL430::writeEemRegister(uint32_t reg, uint32_t value, bool ignoreCache)
{
const size_t slot = reg / 2;
if (slot >= cache.size())
cache.resize(slot);
if (!cache[slot].valid || cache[slot].value != value || ignoreCache)
{
if (!(ema_ && ema_->writeEemRegister((EemRegister)reg, value) && ema_->sync()))
throw EM_RegisterWriteException();
}
cache[slot].value = value;
cache[slot].valid = true;
}
uint32_t TI::DLL430::readEemRegister(uint32_t reg)
{
const size_t slot = reg / 2;
if (slot > cache.size())
cache.resize(slot);
uint32_t value = 0;
if (!(ema_ && ema_->readEemRegister((EemRegister)reg, &value) && ema_->sync()))
throw EM_RegisterReadException();
cache[slot].value = value;
cache[slot].valid = true;
return value;
}
| [
"jckeerthan@gmail.com"
] | jckeerthan@gmail.com |
717b559a0dea926f2a5a58f84964f8f1649bd836 | a9305ca0522007354ec3189c94854bd92ac9a8fa | /URI/1038.cpp | b2e1e705918818faf318c066f1354e23a18e878f | [] | no_license | pkmm91/competitive-programming-solutions | d3e51f4b5aea22d684d0d80d6e23b06c3d5d8cd0 | 323fa71b6e3eae38f997725cda580a5d8ea9bbf4 | refs/heads/master | 2021-01-10T06:15:33.449652 | 2016-03-16T13:53:56 | 2016-03-16T13:57:19 | 54,032,433 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 330 | cpp | #include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
int main()
{
int x,y,count = 0,i;
scanf("%d %d",&x,&y);
int a = min(x,y);
int b = max(x,y);
for (i=a; i <= b ; i++)
{
if (i % 13 == 0)
count++;
}
printf("%d\n",count);
return 0;
}
| [
"pknit1291@gmail.com"
] | pknit1291@gmail.com |
38b6f8d89e5a60c5414555f9702cff2d9d646d84 | b5fbdf1eec6421b5b51255a508c1892790d66939 | /Assignment1/check_brackets.cpp | 604e3135e99ed07876a47469e97fbaa27d197e73 | [] | no_license | erenut/DataStructures | bd95f9ec7bf00677b4adbfe8d6bfcde249083394 | 396438559cee83103fc30cdc46f6afceb3529414 | refs/heads/master | 2021-08-23T07:52:28.941109 | 2017-12-04T06:40:05 | 2017-12-04T06:40:05 | 110,600,412 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,861 | cpp | #include <iostream>
#include <stack>
#include <string>
struct Bracket {
Bracket(char type, int position):
type(type),
position(position)
{}
bool Matchc(char c) {
if (type == '[' && c == ']')
return true;
if (type == '{' && c == '}')
return true;
if (type == '(' && c == ')')
return true;
return false;
}
char type;
int position;
};
int main() {
std::string text;
getline(std::cin, text);
// define the state
bool state = true;
int failIndex = 0;
// Define the stack
std::stack <Bracket> opening_brackets_stack;
for (int position = 0; position < text.length(); ++position) {
char next = text[position];
if (next == '(' || next == '[' || next == '{') {
// Process opening bracket, write your code here
Bracket new_element(next,position);
opening_brackets_stack.push(new_element);
}
if (next == ')' || next == ']' || next == '}') {
// Process closing bracket, write your code here
if (opening_brackets_stack.empty()) {
state = false;
failIndex = position;
break;
}
// if the stack is not empty then it will pop the last element
Bracket top_element = opening_brackets_stack.top();
opening_brackets_stack.pop();
if (!top_element.Matchc(next)){
state = false;
failIndex = position;
break;
}
}
}
// Printing answer, write your code here
if (state && opening_brackets_stack.empty())
std::cout << "Success" << std::endl;
else{
std::cout << (failIndex+1) << std::endl;
//std::cout << state << opening_brackets_stack.empty() << std::endl;
}
return 0;
}
| [
"ue@uw.edu"
] | ue@uw.edu |
71c580c75939e0a48c041d59f04c18544c0a3828 | 04b1803adb6653ecb7cb827c4f4aa616afacf629 | /chromeos/components/tether/host_scan_cache_entry.cc | 234dbd467b1d0c77228d48688ce574f05c19b0a0 | [
"BSD-3-Clause"
] | permissive | Samsung/Castanets | 240d9338e097b75b3f669604315b06f7cf129d64 | 4896f732fc747dfdcfcbac3d442f2d2d42df264a | refs/heads/castanets_76_dev | 2023-08-31T09:01:04.744346 | 2021-07-30T04:56:25 | 2021-08-11T05:45:21 | 125,484,161 | 58 | 49 | BSD-3-Clause | 2022-10-16T19:31:26 | 2018-03-16T08:07:37 | null | UTF-8 | C++ | false | false | 2,880 | cc | // Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/components/tether/host_scan_cache_entry.h"
#include "base/memory/ptr_util.h"
namespace chromeos {
namespace tether {
HostScanCacheEntry::Builder::Builder() = default;
HostScanCacheEntry::Builder::~Builder() = default;
std::unique_ptr<HostScanCacheEntry> HostScanCacheEntry::Builder::Build() {
DCHECK(!tether_network_guid_.empty());
return base::WrapUnique(new HostScanCacheEntry(
tether_network_guid_, device_name_, carrier_, battery_percentage_,
signal_strength_, setup_required_));
}
HostScanCacheEntry::Builder& HostScanCacheEntry::Builder::SetTetherNetworkGuid(
const std::string& tether_network_guid) {
tether_network_guid_ = tether_network_guid;
return *this;
}
HostScanCacheEntry::Builder& HostScanCacheEntry::Builder::SetDeviceName(
const std::string& device_name) {
device_name_ = device_name;
return *this;
}
HostScanCacheEntry::Builder& HostScanCacheEntry::Builder::SetCarrier(
const std::string& carrier) {
carrier_ = carrier;
return *this;
}
HostScanCacheEntry::Builder& HostScanCacheEntry::Builder::SetBatteryPercentage(
int battery_percentage) {
battery_percentage_ = battery_percentage;
return *this;
}
HostScanCacheEntry::Builder& HostScanCacheEntry::Builder::SetSignalStrength(
int signal_strength) {
signal_strength_ = signal_strength;
return *this;
}
HostScanCacheEntry::Builder& HostScanCacheEntry::Builder::SetSetupRequired(
bool setup_required) {
setup_required_ = setup_required;
return *this;
}
HostScanCacheEntry::HostScanCacheEntry(const std::string& tether_network_guid,
const std::string& device_name,
const std::string& carrier,
int battery_percentage,
int signal_strength,
bool setup_required)
: tether_network_guid(tether_network_guid),
device_name(device_name),
carrier(carrier),
battery_percentage(battery_percentage),
signal_strength(signal_strength),
setup_required(setup_required) {}
HostScanCacheEntry::HostScanCacheEntry(const HostScanCacheEntry& other) =
default;
HostScanCacheEntry::~HostScanCacheEntry() = default;
bool HostScanCacheEntry::operator==(const HostScanCacheEntry& other) const {
return tether_network_guid == other.tether_network_guid &&
device_name == other.device_name && carrier == other.carrier &&
battery_percentage == other.battery_percentage &&
signal_strength == other.signal_strength &&
setup_required == other.setup_required;
}
} // namespace tether
} // namespace chromeos
| [
"sunny.nam@samsung.com"
] | sunny.nam@samsung.com |
cb1567aa750e9dd3fe1cf480411851b274ecf2e1 | 97dba80026128e9296e575bb58b9cc7867bbc77f | /hdoj/2586.cpp | 1ba491229ccba6f67903220906cdde7eb687b7a1 | [] | no_license | intfloat/AlgoSolutions | 5272be3dfd72485ff78888325a98c25b2623e3cb | 2f7b2f3c4c8a25eb46322e7f8894263ecd286248 | refs/heads/master | 2021-12-23T08:18:32.176193 | 2021-11-01T05:53:27 | 2021-11-01T05:53:27 | 9,474,989 | 18 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 3,310 | cpp | #include <stdio.h>
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
#include <stack>
#define FOR(i, n) for (int i = 0; i < n; ++i)
using namespace std;
const int MAX_N = 40005;
int head[MAX_N], nt[MAX_N * 2], pnt[MAX_N * 2], wei[MAX_N * 2], ptr1;
int head2[MAX_N], next2[505], pnt2[505], ptr2;
int dis[MAX_N], p[MAX_N];
bool visited[MAX_N];
vector<pair<pair<int, int>, int> > res;
void addedge(int u, int v, int w) {
nt[ptr1] = head[u]; head[u] = ptr1; pnt[ptr1] = v; wei[ptr1++] = w;
nt[ptr1] = head[v]; head[v] = ptr1; pnt[ptr1] = u; wei[ptr1++] = w;
}
void addquery(int u, int v) {
next2[ptr2] = head2[u]; head2[u] = ptr2; pnt2[ptr2++] = v;
next2[ptr2] = head2[v]; head2[v] = ptr2; pnt2[ptr2++] = u;
}
int _find(int idx) {
if (p[idx] == idx) return idx;
p[idx] = _find(p[idx]);
return p[idx];
}
void tarjan_lca(int pos) {
// implement it in a non-recursive way to avoid stack overflow...
stack<pair<int, int> > s;
s.push(make_pair(1, -2));
while (!s.empty()) {
pair<int, int> tp = s.top(); s.pop();
int idx = tp.first;
int ps = tp.second;
// cout << idx << " " << ps << endl;
visited[idx] = true;
if (ps == -2) {
for (int i = head2[idx]; i != -1; i = next2[i]) {
if (visited[pnt2[i]]) {
// cout << idx << " " << pnt2[i] << endl;
pair<int, int> cur = make_pair(min(idx, pnt2[i]), max(idx, pnt2[i]));
res.push_back(make_pair(cur, _find(pnt2[i])));
}
}
if (head[idx] == -1) continue;
int nch = head[idx];
while (nch != -1 && visited[pnt[nch]]) nch = nt[nch];
if (nch == -1) continue;
dis[pnt[nch]] = dis[idx] + wei[nch];
s.push(make_pair(idx, nch));
s.push(make_pair(pnt[nch], -2));
}
else if (ps != -1) {
p[pnt[ps]] = idx;
int nch = nt[ps];
while (nch != -1 && visited[pnt[nch]]) nch = nt[nch];
if (nch == -1) continue;
if (!visited[pnt[nch]]) {
dis[pnt[nch]] = dis[idx] + wei[nch];
s.push(make_pair(idx, nch));
s.push(make_pair(pnt[nch], -2));
}
}
}
return;
}
int main() {
int T, n, m, x, y, w;
scanf("%d", &T);
FOR(tt, T) {
ptr1 = ptr2 = 0;
res.clear();
scanf("%d %d", &n, &m);
FOR(i, MAX_N) {
visited[i] = false;
p[i] = i;
head[i] = head2[i] = -1;
dis[i] = 0;
}
// dis[1] = 0;
FOR(i, n - 1) {
scanf("%d %d %d", &x, &y, &w);
addedge(x, y, w);
}
int A[205], B[205];
FOR(i, m) {
scanf("%d %d", A + i, B + i);
if (A[i] > B[i]) swap(A[i], B[i]);
addquery(A[i], B[i]);
}
tarjan_lca(1);
FOR(i, m) {
FOR(j, res.size()) {
if (res[j].first == make_pair(A[i], B[i])) {
printf("%d\n", dis[A[i]] + dis[B[i]] - 2 * dis[res[j].second]);
break;
}
}
}
}
return 0;
}
| [
"wangliangpeking@gmail.com"
] | wangliangpeking@gmail.com |
26e8251118af896e63149f7bcd9ce3727fe8c973 | 001d7ef8a36267dce80e7390d11c0e33af9dc60b | /network.cpp | 323671d126a516a4f4a92b3136adcc76c91fa270 | [] | no_license | mgammer/glPong | 81a0201c577162bbf6c0f21aee6214d90fd0bb2b | a81a0149f4cb259d36f5bc8be29b856ab094733e | refs/heads/master | 2016-09-06T04:05:21.782702 | 2011-08-25T13:08:33 | 2011-08-25T13:08:33 | 2,078,460 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,851 | cpp | #include "network.h"
network::network(QString ipAddr, QObject *parent) :
QObject(parent)
{
if(ipAddr.isEmpty()) {
// we dont know where to connect => lets be a server
this->server = new QTcpServer();
this->client = NULL;
connect(server, SIGNAL(newConnection()), this, SLOT(newClient()));
this->server->listen(QHostAddress::Any, 1337);
}
else {
// lets be a client
this->server = NULL;
this->client = new QTcpSocket();
connect(client, SIGNAL(connected()), this, SLOT(clientConnected()));
connect(client, SIGNAL(readyRead()), this, SLOT(readIncomingData()));
this->client->connectToHost(QHostAddress(ipAddr), 1337);
}
}
network::~network()
{
if(server)
this->server->close();
if(client)
this->client->close();
}
// server slot
void network::newClient()
{
this->client = server->nextPendingConnection();
connect(client, SIGNAL(readyRead()), this, SLOT(readIncomingData()));
connect(client, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
// since we have a connection now, we are in a network game. emit player 1 role
emit connected(1);
}
//client slot
void network::clientConnected()
{
connect(client, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
// since we have a connection to a server, we are in a network game. emit player 2 role
emit connected(2);
}
void network::clientDisconnected()
{
// client disconnected, emit singleplayer game!
emit connected(0);
this->client->close();
this->client = NULL;
}
void network::sendValue(int value)
{
this->client->write(QByteArray::number(value));
emit sent(value);
}
void network::readIncomingData()
{
QByteArray value(client->readAll());
emit received(value.toInt());
}
| [
"mg_gizmo@yahoo.de"
] | mg_gizmo@yahoo.de |
1b9256e170064225add307ee43421f0375ff9090 | 2ff6642424e5266420d52be15e05604d8d130223 | /baekjoon/10812.cpp | 426d60797f5120fa273bc5e99970cb5175d84e14 | [] | no_license | unilep/algorithm | 848f376fafce322162c9861dd555e7cc668554b3 | 51a986f96f379f64361b6fa0e6e67c5f597321d4 | refs/heads/master | 2020-03-23T18:34:07.622691 | 2019-06-23T15:17:52 | 2019-06-23T15:17:52 | 141,916,962 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 463 | cpp | #include<iostream>
using namespace std;
int N, M, A[101], B[101];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
for (int i = 1; i <= N; i++) B[i] = A[i] = i;
while (M--) {
int I, J, K;
cin >> I >> J >> K;
int L = J - K + 1;
int C = J - I + 1;
for (int i = 0; i < C; i++) B[I + i] = (i >= L ? A[I + i - L] : A[K + i]);
for (int i = 1; i <= N; i++) A[i] = B[i];
}
for (int i = 1; i <= N; i++) cout << A[i] << " ";
}
| [
"noreply@github.com"
] | noreply@github.com |
f1c3d4b38db20132cc93222c5ee5cc97cac8f166 | 8f3856a8c3e71144f9d5d0483c099918e43e0e40 | /Game/Source/GDKTestGymsFunctionalTests/Tests/PredictedGameplayCuesTest/CuesGASTestPawn.cpp | c74222fe5bb02a533d78f35e78475b512a9d7bd6 | [
"MIT"
] | permissive | spatialos/UnrealGDKTestGyms | f870f826b50690e6682da2b72fee531e8ff9b8b0 | fb06a2c0364e6467ca0317fe410ebe319835209f | refs/heads/master | 2022-02-11T01:50:00.041955 | 2022-01-25T09:57:56 | 2022-01-25T09:57:56 | 217,067,291 | 11 | 9 | MIT | 2022-01-25T09:57:57 | 2019-10-23T13:40:57 | C++ | UTF-8 | C++ | false | false | 343 | cpp | // Copyright (c) Improbable Worlds Ltd, All Rights Reserved
#include "CuesGASTestPawn.h"
#include "GA_ApplyCueEffect.h"
ACuesGASTestPawn::ACuesGASTestPawn()
: OnActiveCounter(0)
, ExecuteCounter(0)
{
}
TArray<TSubclassOf<UGameplayAbility>> ACuesGASTestPawn::GetInitialGrantedAbilities()
{
return { UGA_ApplyCueEffect::StaticClass() };
}
| [
"noreply@github.com"
] | noreply@github.com |
e6d497f276635f39a73b882d0b05471b9693c27f | d29d5c3b12bc71073c7f70e13b5c6918afdaf03e | /debugsrv/runmodedebug/rmdriver/src/d_target_process.cpp | 23c4c3c576a17927ad9df353d721291b5453eee6 | [] | no_license | RomanSaveljev/osrndtools | bdbd82c2a2ebeca76767a2cfc431f479fa047cd0 | 305d28826c7105df01951f1ad1a7b93deb9683f6 | refs/heads/master | 2021-01-17T06:45:40.585045 | 2010-10-26T13:20:32 | 2010-10-26T13:20:32 | 59,350,307 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,223 | cpp | // Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// Purpose: The DProcessTracker object tracks which processes are being
// debugged. The DProcessTracker class uses a DTargetProcess object for
// each process being debugged.
// Note: Although TheDProcessTracker object is a global, it should be unique
// as only the Debug Security Server should load and use this driver.
//
//
#include <e32def.h>
#include <e32def_private.h>
#include <e32cmn.h>
#include <e32cmn_private.h>
#include <kernel/kernel.h>
#include <kernel/kern_priv.h>
#include "nk_priv.h"
#include <rm_debug_api.h>
#include "d_target_process.h"
#include "debug_logging.h"
#include "debug_utils.h"
// ctor
DTargetProcess::DTargetProcess()
:iProcessName(NULL)
{
}
// dtor
DTargetProcess::~DTargetProcess()
{
delete iProcessName;
iAgentList.ResetAndDestroy();
}
// Compare two DTargetProcess items. They are the same if they have the same name.
TInt DTargetProcess::Compare(const DTargetProcess& aFirst, const DTargetProcess& aSecond)
{
const TDesC& left = aFirst.iProcessName ? *aFirst.iProcessName : KNullDesC();
const TDesC& right = aSecond.iProcessName ? *aSecond.iProcessName : KNullDesC();
return left.Compare(right);
}
// Set the name of the process we are tracking
TInt DTargetProcess::SetProcessName(const TDesC8& aProcessName)
{
// Argument checking
if (aProcessName.Length() < 1)
{
return KErrArgument;
}
if (iProcessName)
return KErrNotReady; // You can only set the processname once
iProcessName = HBuf8::New(aProcessName);
if (!iProcessName)
return KErrNoMemory;
return KErrNone;
}
// Obtain the name of the process being tracked
const TDesC& DTargetProcess::ProcessName() const
{
return iProcessName ? *iProcessName : KNullDesC();
}
// Returns a pointer to the DDebugAgent with aAgentId.
// If the agent is not in the list, it returns NULL.
DDebugAgent* DTargetProcess::Agent(TUint64 aAgentId)
{
for(TInt i = 0; i < iAgentList.Count(); i++)
{
if (iAgentList[i]->Id() == aAgentId)
{
return iAgentList[i];
}
}
// what do we return if we don't have any agents?
return NULL;
}
// Adds aAgentId as a tracking agent for this process.
TInt DTargetProcess::AddAgent(TUint64 aAgentId)
{
DDebugAgent* agent = DDebugAgent::New(aAgentId);
LOG_MSG4("DTargetProcess::AddAgent(), agentId=%d, curr iAgentList.Count=%d, new agent=0x%08x",
I64LOW(aAgentId), iAgentList.Count(), agent );
if(agent == NULL)
{
LOG_MSG("DTargetProcess::AddAgent() couldn't allocate memory for DDebugAgent");
return KErrNoMemory;
}
return iAgentList.Insert(agent,0);
}
// Stops tracking the process with this agent
TInt DTargetProcess::RemoveAgent(TUint64 aAgentId)
{
// We need to find and then remove the agent
for(TUint i = 0; i < iAgentList.Count(); i++)
{
if (iAgentList[i]->Id() == aAgentId)
{
LOG_MSG4("DTargetProcess::RemoveAgent(), deleting agent[%d], id 0x%x, address=0x%x",
i, I64LOW(aAgentId), iAgentList[i]);
delete iAgentList[i];
iAgentList.Remove(i);
return KErrNone;
}
}
return KErrNotFound;
}
// Index through the agents by position
DDebugAgent* DTargetProcess::operator[](TInt aIndex)
{
return iAgentList[aIndex];
}
// returns the number of agents tracking this process.
TInt DTargetProcess::AgentCount() const
{
return iAgentList.Count();
}
void DTargetProcess::NotifyEvent(const TDriverEventInfo& aEventInfo)
{
// Stuff the event info into all the tracking agents event queues
LOG_MSG4("DTargetProcess::NotifyEvent(): num attached agents: %d, iEventType=%d, this=0x%08x",
AgentCount(), aEventInfo.iEventType, this);
for(TInt i = 0; i < AgentCount(); i++)
{
// Index through all the relevant debug agents
DDebugAgent* debugAgent = iAgentList[i];
if(debugAgent != NULL)
{
debugAgent->NotifyEvent(aEventInfo);
}
}
}
| [
"none@none"
] | none@none |
759feb1fcf8a3e2ea70ad214000c6a63a9e83941 | d90062ba0af9f57fac8cfa04f075abad295907d7 | /app/libs/tesseract/tesseract/ccmain/control.cpp | d2c0868f5998d88ac1735018eef0a44d1d9c20e2 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference",
"BSD-2-Clause"
] | permissive | fynngodau/textfairy | 41d8bbe1ecc04f56b7162ab2f29967d6d1d72eac | 733f2ad2691d2a001e4c83d931a85b944851a652 | refs/heads/master | 2022-12-10T17:57:12.031378 | 2020-09-12T18:44:12 | 2020-09-12T18:44:12 | 295,005,558 | 0 | 0 | Apache-2.0 | 2020-09-12T18:45:30 | 2020-09-12T18:45:29 | null | UTF-8 | C++ | false | false | 77,590 | cpp | /******************************************************************
* File: control.cpp (Formerly control.c)
* Description: Module-independent matcher controller.
* Author: Ray Smith
* Created: Thu Apr 23 11:09:58 BST 1992
* ReHacked: Tue Sep 22 08:42:49 BST 1992 Phil Cheatle
*
* (C) Copyright 1992, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
// Include automatically generated configuration file if running autoconf.
#ifdef HAVE_CONFIG_H
#include "config_auto.h"
#endif
#include <string.h>
#include <math.h>
#ifdef __UNIX__
#include <assert.h>
#include <unistd.h>
#include <errno.h>
#endif
#include <ctype.h>
#include "ocrclass.h"
#include "werdit.h"
#include "drawfx.h"
#include "tessbox.h"
#include "tessvars.h"
#include "pgedit.h"
#include "reject.h"
#include "fixspace.h"
#include "docqual.h"
#include "control.h"
#include "output.h"
#include "callcpp.h"
#include "globals.h"
#include "sorthelper.h"
#include "tesseractclass.h"
#define MIN_FONT_ROW_COUNT 8
#define MAX_XHEIGHT_DIFF 3
const char* const kBackUpConfigFile = "tempconfigdata.config";
// Min believable x-height for any text when refitting as a fraction of
// original x-height
const double kMinRefitXHeightFraction = 0.5;
/**
* Make a word from the selected blobs and run Tess on them.
*
* @param page_res recognise blobs
* @param selection_box within this box
*/
namespace tesseract {
void Tesseract::recog_pseudo_word(PAGE_RES* page_res,
TBOX &selection_box) {
PAGE_RES_IT* it = make_pseudo_word(page_res, selection_box);
if (it != NULL) {
recog_interactive(it);
it->DeleteCurrentWord();
delete it;
}
}
/**
* Recognize a single word in interactive mode.
*
* @param pr_it the page results iterator
*/
BOOL8 Tesseract::recog_interactive(PAGE_RES_IT* pr_it) {
inT16 char_qual;
inT16 good_char_qual;
WordData word_data(*pr_it);
SetupWordPassN(2, &word_data);
classify_word_and_language(2, pr_it, &word_data);
if (tessedit_debug_quality_metrics) {
WERD_RES* word_res = pr_it->word();
word_char_quality(word_res, pr_it->row()->row, &char_qual, &good_char_qual);
tprintf("\n%d chars; word_blob_quality: %d; outline_errs: %d; "
"char_quality: %d; good_char_quality: %d\n",
word_res->reject_map.length(),
word_blob_quality(word_res, pr_it->row()->row),
word_outline_errs(word_res), char_qual, good_char_qual);
}
return TRUE;
}
// Helper function to check for a target word and handle it appropriately.
// Inspired by Jetsoft's requirement to process only single words on pass2
// and beyond.
// If word_config is not null:
// If the word_box and target_word_box overlap, read the word_config file
// else reset to previous config data.
// return true.
// else
// If the word_box and target_word_box overlap or pass <= 1, return true.
// Note that this function uses a fixed temporary file for storing the previous
// configs, so it is neither thread-safe, nor process-safe, but the assumption
// is that it will only be used for one debug window at a time.
//
// Since this function is used for debugging (and not to change OCR results)
// set only debug params from the word config file.
bool Tesseract::ProcessTargetWord(const TBOX& word_box,
const TBOX& target_word_box,
const char* word_config,
int pass) {
if (word_config != NULL) {
if (word_box.major_overlap(target_word_box)) {
if (backup_config_file_ == NULL) {
backup_config_file_ = kBackUpConfigFile;
FILE* config_fp = fopen(backup_config_file_, "wb");
ParamUtils::PrintParams(config_fp, params());
fclose(config_fp);
ParamUtils::ReadParamsFile(word_config,
SET_PARAM_CONSTRAINT_DEBUG_ONLY,
params());
}
} else {
if (backup_config_file_ != NULL) {
ParamUtils::ReadParamsFile(backup_config_file_,
SET_PARAM_CONSTRAINT_DEBUG_ONLY,
params());
backup_config_file_ = NULL;
}
}
} else if (pass > 1 && !word_box.major_overlap(target_word_box)) {
return false;
}
return true;
}
/** If tesseract is to be run, sets the words up ready for it. */
void Tesseract::SetupAllWordsPassN(int pass_n,
const TBOX* target_word_box,
const char* word_config,
PAGE_RES* page_res,
GenericVector<WordData>* words) {
// Prepare all the words.
PAGE_RES_IT page_res_it(page_res);
for (page_res_it.restart_page(); page_res_it.word() != NULL;
page_res_it.forward()) {
if (target_word_box == NULL ||
ProcessTargetWord(page_res_it.word()->word->bounding_box(),
*target_word_box, word_config, 1)) {
words->push_back(WordData(page_res_it));
}
}
// Setup all the words for recognition with polygonal approximation.
for (int w = 0; w < words->size(); ++w) {
SetupWordPassN(pass_n, &(*words)[w]);
if (w > 0) (*words)[w].prev_word = &(*words)[w - 1];
}
}
// Sets up the single word ready for whichever engine is to be run.
void Tesseract::SetupWordPassN(int pass_n, WordData* word) {
if (pass_n == 1 || !word->word->done) {
if (pass_n == 1) {
word->word->SetupForRecognition(unicharset, this, BestPix(),
tessedit_ocr_engine_mode, NULL,
classify_bln_numeric_mode,
textord_use_cjk_fp_model,
poly_allow_detailed_fx,
word->row, word->block);
} else if (pass_n == 2) {
// TODO(rays) Should we do this on pass1 too?
word->word->caps_height = 0.0;
if (word->word->x_height == 0.0f)
word->word->x_height = word->row->x_height();
}
word->lang_words.truncate(0);
for (int s = 0; s <= sub_langs_.size(); ++s) {
// The sub_langs_.size() entry is for the master language.
Tesseract* lang_t = s < sub_langs_.size() ? sub_langs_[s] : this;
WERD_RES* word_res = new WERD_RES;
word_res->InitForRetryRecognition(*word->word);
word->lang_words.push_back(word_res);
// Cube doesn't get setup for pass2.
if (pass_n == 1 || lang_t->tessedit_ocr_engine_mode != OEM_CUBE_ONLY) {
word_res->SetupForRecognition(
lang_t->unicharset, lang_t, BestPix(),
lang_t->tessedit_ocr_engine_mode, NULL,
lang_t->classify_bln_numeric_mode,
lang_t->textord_use_cjk_fp_model,
lang_t->poly_allow_detailed_fx, word->row, word->block);
}
}
}
}
// Runs word recognition on all the words.
bool Tesseract::RecogAllWordsPassN(int pass_n, ETEXT_DESC* monitor,
PAGE_RES_IT* pr_it,
GenericVector<WordData>* words) {
// TODO(rays) Before this loop can be parallelized (it would yield a massive
// speed-up) all remaining member globals need to be converted to local/heap
// (eg set_pass1 and set_pass2) and an intermediate adaption pass needs to be
// added. The results will be significantly different with adaption on, and
// deterioration will need investigation.
pr_it->restart_page();
for (int w = 0; w < words->size(); ++w) {
WordData* word = &(*words)[w];
if (w > 0) word->prev_word = &(*words)[w - 1];
if (monitor != NULL) {
monitor->ocr_alive = TRUE;
if (pass_n == 1) {
monitor->progress = 80 * w / words->size();
if (monitor->progress_callback!=NULL){
TBOX box = pr_it->word()->word->bounding_box();
(*monitor->progress_callback)(monitor->progress_this, monitor->progress,box.left(), box.right(), box.top(), box.bottom());
}
}else {
monitor->progress = 80 + 20 * w / words->size();
if (monitor->progress_callback!=NULL){
TBOX box = pr_it->word()->word->bounding_box();
(*monitor->progress_callback)(monitor->progress_this, monitor->progress,box.left(), box.right(), box.top(), box.bottom());
}
}
if (monitor->deadline_exceeded() ||
(monitor->cancel != NULL && (*monitor->cancel)(monitor->cancel_this,
words->size()))) {
// Timeout. Fake out the rest of the words.
for (; w < words->size(); ++w) {
(*words)[w].word->SetupFake(unicharset);
}
return false;
}
}
if (word->word->tess_failed) {
int s;
for (s = 0; s < word->lang_words.size() &&
word->lang_words[s]->tess_failed; ++s) {}
// If all are failed, skip it. Image words are skipped by this test.
if (s > word->lang_words.size()) continue;
}
// Sync pr_it with the wth WordData.
while (pr_it->word() != NULL && pr_it->word() != word->word)
pr_it->forward();
ASSERT_HOST(pr_it->word() != NULL);
bool make_next_word_fuzzy = false;
if (ReassignDiacritics(pass_n, pr_it, &make_next_word_fuzzy)) {
// Needs to be setup again to see the new outlines in the chopped_word.
SetupWordPassN(pass_n, word);
}
classify_word_and_language(pass_n, pr_it, word);
if (tessedit_dump_choices || debug_noise_removal) {
tprintf("Pass%d: %s [%s]\n", pass_n,
word->word->best_choice->unichar_string().string(),
word->word->best_choice->debug_string().string());
}
pr_it->forward();
if (make_next_word_fuzzy && pr_it->word() != NULL) {
pr_it->MakeCurrentWordFuzzy();
}
}
return true;
}
/**
* recog_all_words()
*
* Walk the page_res, recognizing all the words.
* If monitor is not null, it is used as a progress monitor/timeout/cancel.
* If dopasses is 0, all recognition passes are run,
* 1 just pass 1, 2 passes2 and higher.
* If target_word_box is not null, special things are done to words that
* overlap the target_word_box:
* if word_config is not null, the word config file is read for just the
* target word(s), otherwise, on pass 2 and beyond ONLY the target words
* are processed (Jetsoft modification.)
* Returns false if we cancelled prematurely.
*
* @param page_res page structure
* @param monitor progress monitor
* @param word_config word_config file
* @param target_word_box specifies just to extract a rectangle
* @param dopasses 0 - all, 1 just pass 1, 2 passes 2 and higher
*/
bool Tesseract::recog_all_words(PAGE_RES* page_res,
ETEXT_DESC* monitor,
const TBOX* target_word_box,
const char* word_config,
int dopasses) {
PAGE_RES_IT page_res_it(page_res);
if (tessedit_minimal_rej_pass1) {
tessedit_test_adaption.set_value (TRUE);
tessedit_minimal_rejection.set_value (TRUE);
}
if (dopasses==0 || dopasses==1) {
page_res_it.restart_page();
// ****************** Pass 1 *******************
// If the adaptive classifier is full switch to one we prepared earlier,
// ie on the previous page. If the current adaptive classifier is non-empty,
// prepare a backup starting at this page, in case it fills up. Do all this
// independently for each language.
if (AdaptiveClassifierIsFull()) {
SwitchAdaptiveClassifier();
} else if (!AdaptiveClassifierIsEmpty()) {
StartBackupAdaptiveClassifier();
}
// Now check the sub-langs as well.
for (int i = 0; i < sub_langs_.size(); ++i) {
if (sub_langs_[i]->AdaptiveClassifierIsFull()) {
sub_langs_[i]->SwitchAdaptiveClassifier();
} else if (!sub_langs_[i]->AdaptiveClassifierIsEmpty()) {
sub_langs_[i]->StartBackupAdaptiveClassifier();
}
}
// Set up all words ready for recognition, so that if parallelism is on
// all the input and output classes are ready to run the classifier.
GenericVector<WordData> words;
SetupAllWordsPassN(1, target_word_box, word_config, page_res, &words);
if (tessedit_parallelize) {
PrerecAllWordsPar(words);
}
stats_.word_count = words.size();
stats_.dict_words = 0;
stats_.doc_blob_quality = 0;
stats_.doc_outline_errs = 0;
stats_.doc_char_quality = 0;
stats_.good_char_count = 0;
stats_.doc_good_char_quality = 0;
most_recently_used_ = this;
// Run pass 1 word recognition.
if (!RecogAllWordsPassN(1, monitor, &page_res_it, &words)) return false;
// Pass 1 post-processing.
for (page_res_it.restart_page(); page_res_it.word() != NULL;
page_res_it.forward()) {
if (page_res_it.word()->word->flag(W_REP_CHAR)) {
fix_rep_char(&page_res_it);
continue;
}
// Count dict words.
if (page_res_it.word()->best_choice->permuter() == USER_DAWG_PERM)
++(stats_.dict_words);
// Update misadaption log (we only need to do it on pass 1, since
// adaption only happens on this pass).
if (page_res_it.word()->blamer_bundle != NULL &&
page_res_it.word()->blamer_bundle->misadaption_debug().length() > 0) {
page_res->misadaption_log.push_back(
page_res_it.word()->blamer_bundle->misadaption_debug());
}
}
}
if (dopasses == 1) return true;
// ****************** Pass 2 *******************
if (tessedit_tess_adaption_mode != 0x0 && !tessedit_test_adaption &&
AnyTessLang()) {
page_res_it.restart_page();
GenericVector<WordData> words;
SetupAllWordsPassN(2, target_word_box, word_config, page_res, &words);
if (tessedit_parallelize) {
PrerecAllWordsPar(words);
}
most_recently_used_ = this;
// Run pass 2 word recognition.
if (!RecogAllWordsPassN(2, monitor, &page_res_it, &words)) return false;
}
// The next passes can only be run if tesseract has been used, as cube
// doesn't set all the necessary outputs in WERD_RES.
if (AnyTessLang()) {
// ****************** Pass 3 *******************
// Fix fuzzy spaces.
set_global_loc_code(LOC_FUZZY_SPACE);
if (!tessedit_test_adaption && tessedit_fix_fuzzy_spaces
&& !tessedit_word_for_word && !right_to_left())
fix_fuzzy_spaces(monitor, stats_.word_count, page_res);
// ****************** Pass 4 *******************
if (tessedit_enable_dict_correction) dictionary_correction_pass(page_res);
if (tessedit_enable_bigram_correction) bigram_correction_pass(page_res);
// ****************** Pass 5,6 *******************
rejection_passes(page_res, monitor, target_word_box, word_config);
#ifndef NO_CUBE_BUILD
// ****************** Pass 7 *******************
// Cube combiner.
// If cube is loaded and its combiner is present, run it.
if (tessedit_ocr_engine_mode == OEM_TESSERACT_CUBE_COMBINED) {
run_cube_combiner(page_res);
}
#endif
// ****************** Pass 8 *******************
font_recognition_pass(page_res);
// ****************** Pass 9 *******************
// Check the correctness of the final results.
blamer_pass(page_res);
script_pos_pass(page_res);
}
// Write results pass.
set_global_loc_code(LOC_WRITE_RESULTS);
// This is now redundant, but retained commented so show how to obtain
// bounding boxes and style information.
// changed by jetsoft
// needed for dll to output memory structure
if ((dopasses == 0 || dopasses == 2) && (monitor || tessedit_write_unlv))
output_pass(page_res_it, target_word_box);
// end jetsoft
PageSegMode pageseg_mode = static_cast<PageSegMode>(
static_cast<int>(tessedit_pageseg_mode));
textord_.CleanupSingleRowResult(pageseg_mode, page_res);
// Remove empty words, as these mess up the result iterators.
for (page_res_it.restart_page(); page_res_it.word() != NULL;
page_res_it.forward()) {
WERD_RES* word = page_res_it.word();
if (word->best_choice == NULL || word->best_choice->length() == 0)
page_res_it.DeleteCurrentWord();
}
if (monitor != NULL) {
monitor->progress = 100;
}
return true;
}
void Tesseract::bigram_correction_pass(PAGE_RES *page_res) {
PAGE_RES_IT word_it(page_res);
WERD_RES *w_prev = NULL;
WERD_RES *w = word_it.word();
while (1) {
w_prev = w;
while (word_it.forward() != NULL &&
(!word_it.word() || word_it.word()->part_of_combo)) {
// advance word_it, skipping over parts of combos
}
if (!word_it.word()) break;
w = word_it.word();
if (!w || !w_prev || w->uch_set != w_prev->uch_set) {
continue;
}
if (w_prev->word->flag(W_REP_CHAR) || w->word->flag(W_REP_CHAR)) {
if (tessedit_bigram_debug) {
tprintf("Skipping because one of the words is W_REP_CHAR\n");
}
continue;
}
// Two words sharing the same language model, excellent!
GenericVector<WERD_CHOICE *> overrides_word1;
GenericVector<WERD_CHOICE *> overrides_word2;
STRING orig_w1_str = w_prev->best_choice->unichar_string();
STRING orig_w2_str = w->best_choice->unichar_string();
WERD_CHOICE prev_best(w->uch_set);
{
int w1start, w1end;
w_prev->best_choice->GetNonSuperscriptSpan(&w1start, &w1end);
prev_best = w_prev->best_choice->shallow_copy(w1start, w1end);
}
WERD_CHOICE this_best(w->uch_set);
{
int w2start, w2end;
w->best_choice->GetNonSuperscriptSpan(&w2start, &w2end);
this_best = w->best_choice->shallow_copy(w2start, w2end);
}
if (w->tesseract->getDict().valid_bigram(prev_best, this_best)) {
if (tessedit_bigram_debug) {
tprintf("Top choice \"%s %s\" verified by bigram model.\n",
orig_w1_str.string(), orig_w2_str.string());
}
continue;
}
if (tessedit_bigram_debug > 2) {
tprintf("Examining alt choices for \"%s %s\".\n",
orig_w1_str.string(), orig_w2_str.string());
}
if (tessedit_bigram_debug > 1) {
if (!w_prev->best_choices.singleton()) {
w_prev->PrintBestChoices();
}
if (!w->best_choices.singleton()) {
w->PrintBestChoices();
}
}
float best_rating = 0.0;
int best_idx = 0;
WERD_CHOICE_IT prev_it(&w_prev->best_choices);
for (prev_it.mark_cycle_pt(); !prev_it.cycled_list(); prev_it.forward()) {
WERD_CHOICE *p1 = prev_it.data();
WERD_CHOICE strip1(w->uch_set);
{
int p1start, p1end;
p1->GetNonSuperscriptSpan(&p1start, &p1end);
strip1 = p1->shallow_copy(p1start, p1end);
}
WERD_CHOICE_IT w_it(&w->best_choices);
for (w_it.mark_cycle_pt(); !w_it.cycled_list(); w_it.forward()) {
WERD_CHOICE *p2 = w_it.data();
WERD_CHOICE strip2(w->uch_set);
{
int p2start, p2end;
p2->GetNonSuperscriptSpan(&p2start, &p2end);
strip2 = p2->shallow_copy(p2start, p2end);
}
if (w->tesseract->getDict().valid_bigram(strip1, strip2)) {
overrides_word1.push_back(p1);
overrides_word2.push_back(p2);
if (overrides_word1.size() == 1 ||
p1->rating() + p2->rating() < best_rating) {
best_rating = p1->rating() + p2->rating();
best_idx = overrides_word1.size() - 1;
}
}
}
}
if (!overrides_word1.empty()) {
// Excellent, we have some bigram matches.
if (EqualIgnoringCaseAndTerminalPunct(*w_prev->best_choice,
*overrides_word1[best_idx]) &&
EqualIgnoringCaseAndTerminalPunct(*w->best_choice,
*overrides_word2[best_idx])) {
if (tessedit_bigram_debug > 1) {
tprintf("Top choice \"%s %s\" verified (sans case) by bigram "
"model.\n", orig_w1_str.string(), orig_w2_str.string());
}
continue;
}
STRING new_w1_str = overrides_word1[best_idx]->unichar_string();
STRING new_w2_str = overrides_word2[best_idx]->unichar_string();
if (new_w1_str != orig_w1_str) {
w_prev->ReplaceBestChoice(overrides_word1[best_idx]);
}
if (new_w2_str != orig_w2_str) {
w->ReplaceBestChoice(overrides_word2[best_idx]);
}
if (tessedit_bigram_debug > 0) {
STRING choices_description;
int num_bigram_choices
= overrides_word1.size() * overrides_word2.size();
if (num_bigram_choices == 1) {
choices_description = "This was the unique bigram choice.";
} else {
if (tessedit_bigram_debug > 1) {
STRING bigrams_list;
const int kMaxChoicesToPrint = 20;
for (int i = 0; i < overrides_word1.size() &&
i < kMaxChoicesToPrint; i++) {
if (i > 0) { bigrams_list += ", "; }
WERD_CHOICE *p1 = overrides_word1[i];
WERD_CHOICE *p2 = overrides_word2[i];
bigrams_list += p1->unichar_string() + " " + p2->unichar_string();
if (i == kMaxChoicesToPrint) {
bigrams_list += " ...";
}
}
choices_description = "There were many choices: {";
choices_description += bigrams_list;
choices_description += "}";
} else {
choices_description.add_str_int("There were ", num_bigram_choices);
choices_description += " compatible bigrams.";
}
}
tprintf("Replaced \"%s %s\" with \"%s %s\" with bigram model. %s\n",
orig_w1_str.string(), orig_w2_str.string(),
new_w1_str.string(), new_w2_str.string(),
choices_description.string());
}
}
}
}
void Tesseract::rejection_passes(PAGE_RES* page_res,
ETEXT_DESC* monitor,
const TBOX* target_word_box,
const char* word_config) {
PAGE_RES_IT page_res_it(page_res);
// ****************** Pass 5 *******************
// Gather statistics on rejects.
int word_index = 0;
while (!tessedit_test_adaption && page_res_it.word() != NULL) {
set_global_loc_code(LOC_MM_ADAPT);
WERD_RES* word = page_res_it.word();
word_index++;
if (monitor != NULL) {
monitor->ocr_alive = TRUE;
monitor->progress = 95 + 5 * word_index / stats_.word_count;
}
if (word->rebuild_word == NULL) {
// Word was not processed by tesseract.
page_res_it.forward();
continue;
}
check_debug_pt(word, 70);
// changed by jetsoft
// specific to its needs to extract one word when need
if (target_word_box &&
!ProcessTargetWord(word->word->bounding_box(),
*target_word_box, word_config, 4)) {
page_res_it.forward();
continue;
}
// end jetsoft
page_res_it.rej_stat_word();
int chars_in_word = word->reject_map.length();
int rejects_in_word = word->reject_map.reject_count();
int blob_quality = word_blob_quality(word, page_res_it.row()->row);
stats_.doc_blob_quality += blob_quality;
int outline_errs = word_outline_errs(word);
stats_.doc_outline_errs += outline_errs;
inT16 all_char_quality;
inT16 accepted_all_char_quality;
word_char_quality(word, page_res_it.row()->row,
&all_char_quality, &accepted_all_char_quality);
stats_.doc_char_quality += all_char_quality;
uinT8 permuter_type = word->best_choice->permuter();
if ((permuter_type == SYSTEM_DAWG_PERM) ||
(permuter_type == FREQ_DAWG_PERM) ||
(permuter_type == USER_DAWG_PERM)) {
stats_.good_char_count += chars_in_word - rejects_in_word;
stats_.doc_good_char_quality += accepted_all_char_quality;
}
check_debug_pt(word, 80);
if (tessedit_reject_bad_qual_wds &&
(blob_quality == 0) && (outline_errs >= chars_in_word))
word->reject_map.rej_word_bad_quality();
check_debug_pt(word, 90);
page_res_it.forward();
}
if (tessedit_debug_quality_metrics) {
tprintf
("QUALITY: num_chs= %d num_rejs= %d %5.3f blob_qual= %d %5.3f"
" outline_errs= %d %5.3f char_qual= %d %5.3f good_ch_qual= %d %5.3f\n",
page_res->char_count, page_res->rej_count,
page_res->rej_count / static_cast<float>(page_res->char_count),
stats_.doc_blob_quality,
stats_.doc_blob_quality / static_cast<float>(page_res->char_count),
stats_.doc_outline_errs,
stats_.doc_outline_errs / static_cast<float>(page_res->char_count),
stats_.doc_char_quality,
stats_.doc_char_quality / static_cast<float>(page_res->char_count),
stats_.doc_good_char_quality,
(stats_.good_char_count > 0) ?
(stats_.doc_good_char_quality /
static_cast<float>(stats_.good_char_count)) : 0.0);
}
BOOL8 good_quality_doc =
((page_res->rej_count / static_cast<float>(page_res->char_count)) <=
quality_rej_pc) &&
(stats_.doc_blob_quality / static_cast<float>(page_res->char_count) >=
quality_blob_pc) &&
(stats_.doc_outline_errs / static_cast<float>(page_res->char_count) <=
quality_outline_pc) &&
(stats_.doc_char_quality / static_cast<float>(page_res->char_count) >=
quality_char_pc);
// ****************** Pass 6 *******************
// Do whole document or whole block rejection pass
if (!tessedit_test_adaption) {
set_global_loc_code(LOC_DOC_BLK_REJ);
quality_based_rejection(page_res_it, good_quality_doc);
}
}
void Tesseract::blamer_pass(PAGE_RES* page_res) {
if (!wordrec_run_blamer) return;
PAGE_RES_IT page_res_it(page_res);
for (page_res_it.restart_page(); page_res_it.word() != NULL;
page_res_it.forward()) {
WERD_RES *word = page_res_it.word();
BlamerBundle::LastChanceBlame(wordrec_debug_blamer, word);
page_res->blame_reasons[word->blamer_bundle->incorrect_result_reason()]++;
}
tprintf("Blame reasons:\n");
for (int bl = 0; bl < IRR_NUM_REASONS; ++bl) {
tprintf("%s %d\n", BlamerBundle::IncorrectReasonName(
static_cast<IncorrectResultReason>(bl)),
page_res->blame_reasons[bl]);
}
if (page_res->misadaption_log.length() > 0) {
tprintf("Misadaption log:\n");
for (int i = 0; i < page_res->misadaption_log.length(); ++i) {
tprintf("%s\n", page_res->misadaption_log[i].string());
}
}
}
// Sets script positions and detects smallcaps on all output words.
void Tesseract::script_pos_pass(PAGE_RES* page_res) {
PAGE_RES_IT page_res_it(page_res);
for (page_res_it.restart_page(); page_res_it.word() != NULL;
page_res_it.forward()) {
WERD_RES* word = page_res_it.word();
if (word->word->flag(W_REP_CHAR)) {
page_res_it.forward();
continue;
}
float x_height = page_res_it.block()->block->x_height();
float word_x_height = word->x_height;
if (word_x_height < word->best_choice->min_x_height() ||
word_x_height > word->best_choice->max_x_height()) {
word_x_height = (word->best_choice->min_x_height() +
word->best_choice->max_x_height()) / 2.0f;
}
// Test for small caps. Word capheight must be close to block xheight,
// and word must contain no lower case letters, and at least one upper case.
double small_cap_xheight = x_height * kXHeightCapRatio;
double small_cap_delta = (x_height - small_cap_xheight) / 2.0;
if (word->uch_set->script_has_xheight() &&
small_cap_xheight - small_cap_delta <= word_x_height &&
word_x_height <= small_cap_xheight + small_cap_delta) {
// Scan for upper/lower.
int num_upper = 0;
int num_lower = 0;
for (int i = 0; i < word->best_choice->length(); ++i) {
if (word->uch_set->get_isupper(word->best_choice->unichar_id(i)))
++num_upper;
else if (word->uch_set->get_islower(word->best_choice->unichar_id(i)))
++num_lower;
}
if (num_upper > 0 && num_lower == 0)
word->small_caps = true;
}
word->SetScriptPositions();
}
}
// Factored helper considers the indexed word and updates all the pointed
// values.
static void EvaluateWord(const PointerVector<WERD_RES>& words, int index,
float* rating, float* certainty, bool* bad,
bool* valid_permuter, int* right, int* next_left) {
*right = -MAX_INT32;
*next_left = MAX_INT32;
if (index < words.size()) {
WERD_CHOICE* choice = words[index]->best_choice;
if (choice == NULL) {
*bad = true;
} else {
*rating += choice->rating();
*certainty = MIN(*certainty, choice->certainty());
if (!Dict::valid_word_permuter(choice->permuter(), false))
*valid_permuter = false;
}
*right = words[index]->word->bounding_box().right();
if (index + 1 < words.size())
*next_left = words[index + 1]->word->bounding_box().left();
} else {
*valid_permuter = false;
*bad = true;
}
}
// Helper chooses the best combination of words, transferring good ones from
// new_words to best_words. To win, a new word must have (better rating and
// certainty) or (better permuter status and rating within rating ratio and
// certainty within certainty margin) than current best.
// All the new_words are consumed (moved to best_words or deleted.)
// The return value is the number of new_words used minus the number of
// best_words that remain in the output.
static int SelectBestWords(double rating_ratio,
double certainty_margin,
bool debug,
PointerVector<WERD_RES>* new_words,
PointerVector<WERD_RES>* best_words) {
// Process the smallest groups of words that have an overlapping word
// boundary at the end.
GenericVector<WERD_RES*> out_words;
// Index into each word vector (best, new).
int b = 0, n = 0;
int num_best = 0, num_new = 0;
while (b < best_words->size() || n < new_words->size()) {
// Start of the current run in each.
int start_b = b, start_n = n;
// Rating of the current run in each.
float b_rating = 0.0f, n_rating = 0.0f;
// Certainty of the current run in each.
float b_certainty = 0.0f, n_certainty = 0.0f;
// True if any word is missing its best choice.
bool b_bad = false, n_bad = false;
// True if all words have a valid permuter.
bool b_valid_permuter = true, n_valid_permuter = true;
while (b < best_words->size() || n < new_words->size()) {
int b_right = -MAX_INT32;
int next_b_left = MAX_INT32;
EvaluateWord(*best_words, b, &b_rating, &b_certainty, &b_bad,
&b_valid_permuter, &b_right, &next_b_left);
int n_right = -MAX_INT32;
int next_n_left = MAX_INT32;
EvaluateWord(*new_words, n, &n_rating, &n_certainty, &n_bad,
&n_valid_permuter, &n_right, &next_n_left);
if (MAX(b_right, n_right) < MIN(next_b_left, next_n_left)) {
// The word breaks overlap. [start_b,b] and [start_n, n] match.
break;
}
// Keep searching for the matching word break.
if ((b_right < n_right && b < best_words->size()) ||
n == new_words->size())
++b;
else
++n;
}
bool new_better = false;
if (!n_bad && (b_bad || (n_certainty > b_certainty &&
n_rating < b_rating) ||
(!b_valid_permuter && n_valid_permuter &&
n_rating < b_rating * rating_ratio &&
n_certainty > b_certainty - certainty_margin))) {
// New is better.
for (int i = start_n; i <= n; ++i) {
out_words.push_back((*new_words)[i]);
(*new_words)[i] = NULL;
++num_new;
}
new_better = true;
} else if (!b_bad) {
// Current best is better.
for (int i = start_b; i <= b; ++i) {
out_words.push_back((*best_words)[i]);
(*best_words)[i] = NULL;
++num_best;
}
}
int end_b = b < best_words->size() ? b + 1 : b;
int end_n = n < new_words->size() ? n + 1 : n;
if (debug) {
tprintf("%d new words %s than %d old words: r: %g v %g c: %g v %g"
" valid dict: %d v %d\n",
end_n - start_n, new_better ? "better" : "worse",
end_b - start_b, n_rating, b_rating,
n_certainty, b_certainty, n_valid_permuter, b_valid_permuter);
}
// Move on to the next group.
b = end_b;
n = end_n;
}
// Transfer from out_words to best_words.
best_words->clear();
for (int i = 0; i < out_words.size(); ++i)
best_words->push_back(out_words[i]);
return num_new - num_best;
}
// Helper to recognize the word using the given (language-specific) tesseract.
// Returns positive if this recognizer found more new best words than the
// number kept from best_words.
int Tesseract::RetryWithLanguage(const WordData& word_data,
WordRecognizer recognizer,
WERD_RES** in_word,
PointerVector<WERD_RES>* best_words) {
bool debug = classify_debug_level || cube_debug_level;
if (debug) {
tprintf("Trying word using lang %s, oem %d\n",
lang.string(), static_cast<int>(tessedit_ocr_engine_mode));
}
// Run the recognizer on the word.
PointerVector<WERD_RES> new_words;
(this->*recognizer)(word_data, in_word, &new_words);
if (new_words.empty()) {
// Transfer input word to new_words, as the classifier must have put
// the result back in the input.
new_words.push_back(*in_word);
*in_word = NULL;
}
if (debug) {
for (int i = 0; i < new_words.size(); ++i)
new_words[i]->DebugTopChoice("Lang result");
}
// Initial version is a bit of a hack based on better certainty and rating
// (to reduce false positives from cube) or a dictionary vs non-dictionary
// word.
return SelectBestWords(classify_max_rating_ratio,
classify_max_certainty_margin,
debug, &new_words, best_words);
}
// Helper returns true if all the words are acceptable.
static bool WordsAcceptable(const PointerVector<WERD_RES>& words) {
for (int w = 0; w < words.size(); ++w) {
if (words[w]->tess_failed || !words[w]->tess_accepted) return false;
}
return true;
}
// Moves good-looking "noise"/diacritics from the reject list to the main
// blob list on the current word. Returns true if anything was done, and
// sets make_next_word_fuzzy if blob(s) were added to the end of the word.
bool Tesseract::ReassignDiacritics(int pass, PAGE_RES_IT* pr_it,
bool* make_next_word_fuzzy) {
*make_next_word_fuzzy = false;
WERD* real_word = pr_it->word()->word;
if (real_word->rej_cblob_list()->empty() ||
real_word->cblob_list()->empty() ||
real_word->rej_cblob_list()->length() > noise_maxperword)
return false;
real_word->rej_cblob_list()->sort(&C_BLOB::SortByXMiddle);
// Get the noise outlines into a vector with matching bool map.
GenericVector<C_OUTLINE*> outlines;
real_word->GetNoiseOutlines(&outlines);
GenericVector<bool> word_wanted;
GenericVector<bool> overlapped_any_blob;
GenericVector<C_BLOB*> target_blobs;
AssignDiacriticsToOverlappingBlobs(outlines, pass, real_word, pr_it,
&word_wanted, &overlapped_any_blob,
&target_blobs);
// Filter the outlines that overlapped any blob and put them into the word
// now. This simplifies the remaining task and also makes it more accurate
// as it has more completed blobs to work on.
GenericVector<bool> wanted;
GenericVector<C_BLOB*> wanted_blobs;
GenericVector<C_OUTLINE*> wanted_outlines;
int num_overlapped = 0;
int num_overlapped_used = 0;
for (int i = 0; i < overlapped_any_blob.size(); ++i) {
if (overlapped_any_blob[i]) {
++num_overlapped;
if (word_wanted[i]) ++num_overlapped_used;
wanted.push_back(word_wanted[i]);
wanted_blobs.push_back(target_blobs[i]);
wanted_outlines.push_back(outlines[i]);
outlines[i] = NULL;
}
}
real_word->AddSelectedOutlines(wanted, wanted_blobs, wanted_outlines, NULL);
AssignDiacriticsToNewBlobs(outlines, pass, real_word, pr_it, &word_wanted,
&target_blobs);
int non_overlapped = 0;
int non_overlapped_used = 0;
for (int i = 0; i < word_wanted.size(); ++i) {
if (word_wanted[i]) ++non_overlapped_used;
if (outlines[i] != NULL) ++non_overlapped_used;
}
if (debug_noise_removal) {
tprintf("Used %d/%d overlapped %d/%d non-overlaped diacritics on word:",
num_overlapped_used, num_overlapped, non_overlapped_used,
non_overlapped);
real_word->bounding_box().print();
}
// Now we have decided which outlines we want, put them into the real_word.
if (real_word->AddSelectedOutlines(word_wanted, target_blobs, outlines,
make_next_word_fuzzy)) {
pr_it->MakeCurrentWordFuzzy();
}
// TODO(rays) Parts of combos have a deep copy of the real word, and need
// to have their noise outlines moved/assigned in the same way!!
return num_overlapped_used != 0 || non_overlapped_used != 0;
}
// Attempts to put noise/diacritic outlines into the blobs that they overlap.
// Input: a set of noisy outlines that probably belong to the real_word.
// Output: word_wanted indicates which outlines are to be assigned to a blob,
// target_blobs indicates which to assign to, and overlapped_any_blob is
// true for all outlines that overlapped a blob.
void Tesseract::AssignDiacriticsToOverlappingBlobs(
const GenericVector<C_OUTLINE*>& outlines, int pass, WERD* real_word,
PAGE_RES_IT* pr_it, GenericVector<bool>* word_wanted,
GenericVector<bool>* overlapped_any_blob,
GenericVector<C_BLOB*>* target_blobs) {
GenericVector<bool> blob_wanted;
word_wanted->init_to_size(outlines.size(), false);
overlapped_any_blob->init_to_size(outlines.size(), false);
target_blobs->init_to_size(outlines.size(), NULL);
// For each real blob, find the outlines that seriously overlap it.
// A single blob could be several merged characters, so there can be quite
// a few outlines overlapping, and the full engine needs to be used to chop
// and join to get a sensible result.
C_BLOB_IT blob_it(real_word->cblob_list());
for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) {
C_BLOB* blob = blob_it.data();
TBOX blob_box = blob->bounding_box();
blob_wanted.init_to_size(outlines.size(), false);
int num_blob_outlines = 0;
for (int i = 0; i < outlines.size(); ++i) {
if (blob_box.major_x_overlap(outlines[i]->bounding_box()) &&
!(*word_wanted)[i]) {
blob_wanted[i] = true;
(*overlapped_any_blob)[i] = true;
++num_blob_outlines;
}
}
if (debug_noise_removal) {
tprintf("%d noise outlines overlap blob at:", num_blob_outlines);
blob_box.print();
}
// If any outlines overlap the blob, and not too many, classify the blob
// (using the full engine, languages and all), and choose the maximal
// combination of outlines that doesn't hurt the end-result classification
// by too much. Mark them as wanted.
if (0 < num_blob_outlines && num_blob_outlines < noise_maxperblob) {
if (SelectGoodDiacriticOutlines(pass, noise_cert_basechar, pr_it, blob,
outlines, num_blob_outlines,
&blob_wanted)) {
for (int i = 0; i < blob_wanted.size(); ++i) {
if (blob_wanted[i]) {
// Claim the outline and record where it is going.
(*word_wanted)[i] = true;
(*target_blobs)[i] = blob;
}
}
}
}
}
}
// Attempts to assign non-overlapping outlines to their nearest blobs or
// make new blobs out of them.
void Tesseract::AssignDiacriticsToNewBlobs(
const GenericVector<C_OUTLINE*>& outlines, int pass, WERD* real_word,
PAGE_RES_IT* pr_it, GenericVector<bool>* word_wanted,
GenericVector<C_BLOB*>* target_blobs) {
GenericVector<bool> blob_wanted;
word_wanted->init_to_size(outlines.size(), false);
target_blobs->init_to_size(outlines.size(), NULL);
// Check for outlines that need to be turned into stand-alone blobs.
for (int i = 0; i < outlines.size(); ++i) {
if (outlines[i] == NULL) continue;
// Get a set of adjacent outlines that don't overlap any existing blob.
blob_wanted.init_to_size(outlines.size(), false);
int num_blob_outlines = 0;
TBOX total_ol_box(outlines[i]->bounding_box());
while (i < outlines.size() && outlines[i] != NULL) {
blob_wanted[i] = true;
total_ol_box += outlines[i]->bounding_box();
++i;
++num_blob_outlines;
}
// Find the insertion point.
C_BLOB_IT blob_it(real_word->cblob_list());
while (!blob_it.at_last() &&
blob_it.data_relative(1)->bounding_box().left() <=
total_ol_box.left()) {
blob_it.forward();
}
// Choose which combination of them we actually want and where to put
// them.
if (debug_noise_removal)
tprintf("Num blobless outlines = %d\n", num_blob_outlines);
C_BLOB* left_blob = blob_it.data();
TBOX left_box = left_blob->bounding_box();
C_BLOB* right_blob = blob_it.at_last() ? NULL : blob_it.data_relative(1);
if ((left_box.x_overlap(total_ol_box) || right_blob == NULL ||
!right_blob->bounding_box().x_overlap(total_ol_box)) &&
SelectGoodDiacriticOutlines(pass, noise_cert_disjoint, pr_it, left_blob,
outlines, num_blob_outlines,
&blob_wanted)) {
if (debug_noise_removal) tprintf("Added to left blob\n");
for (int j = 0; j < blob_wanted.size(); ++j) {
if (blob_wanted[j]) {
(*word_wanted)[j] = true;
(*target_blobs)[j] = left_blob;
}
}
} else if (right_blob != NULL &&
(!left_box.x_overlap(total_ol_box) ||
right_blob->bounding_box().x_overlap(total_ol_box)) &&
SelectGoodDiacriticOutlines(pass, noise_cert_disjoint, pr_it,
right_blob, outlines,
num_blob_outlines, &blob_wanted)) {
if (debug_noise_removal) tprintf("Added to right blob\n");
for (int j = 0; j < blob_wanted.size(); ++j) {
if (blob_wanted[j]) {
(*word_wanted)[j] = true;
(*target_blobs)[j] = right_blob;
}
}
} else if (SelectGoodDiacriticOutlines(pass, noise_cert_punc, pr_it, NULL,
outlines, num_blob_outlines,
&blob_wanted)) {
if (debug_noise_removal) tprintf("Fitted between blobs\n");
for (int j = 0; j < blob_wanted.size(); ++j) {
if (blob_wanted[j]) {
(*word_wanted)[j] = true;
(*target_blobs)[j] = NULL;
}
}
}
}
}
// Starting with ok_outlines set to indicate which outlines overlap the blob,
// chooses the optimal set (approximately) and returns true if any outlines
// are desired, in which case ok_outlines indicates which ones.
bool Tesseract::SelectGoodDiacriticOutlines(
int pass, float certainty_threshold, PAGE_RES_IT* pr_it, C_BLOB* blob,
const GenericVector<C_OUTLINE*>& outlines, int num_outlines,
GenericVector<bool>* ok_outlines) {
STRING best_str;
float target_cert = certainty_threshold;
if (blob != NULL) {
float target_c2;
target_cert = ClassifyBlobAsWord(pass, pr_it, blob, &best_str, &target_c2);
if (debug_noise_removal) {
tprintf("No Noise blob classified as %s=%g(%g) at:", best_str.string(),
target_cert, target_c2);
blob->bounding_box().print();
}
target_cert -= (target_cert - certainty_threshold) * noise_cert_factor;
}
GenericVector<bool> test_outlines = *ok_outlines;
// Start with all the outlines in.
STRING all_str;
GenericVector<bool> best_outlines = *ok_outlines;
float best_cert = ClassifyBlobPlusOutlines(test_outlines, outlines, pass,
pr_it, blob, &all_str);
if (debug_noise_removal) {
TBOX ol_box;
for (int i = 0; i < test_outlines.size(); ++i) {
if (test_outlines[i]) ol_box += outlines[i]->bounding_box();
}
tprintf("All Noise blob classified as %s=%g, delta=%g at:",
all_str.string(), best_cert, best_cert - target_cert);
ol_box.print();
}
// Iteratively zero out the bit that improves the certainty the most, until
// we get past the threshold, have zero bits, or fail to improve.
int best_index = 0; // To zero out.
while (num_outlines > 1 && best_index >= 0 &&
(blob == NULL || best_cert < target_cert || blob != NULL)) {
// Find the best bit to zero out.
best_index = -1;
for (int i = 0; i < outlines.size(); ++i) {
if (test_outlines[i]) {
test_outlines[i] = false;
STRING str;
float cert = ClassifyBlobPlusOutlines(test_outlines, outlines, pass,
pr_it, blob, &str);
if (debug_noise_removal) {
TBOX ol_box;
for (int j = 0; j < outlines.size(); ++j) {
if (test_outlines[j]) ol_box += outlines[j]->bounding_box();
tprintf("%d", test_outlines[j]);
}
tprintf(" blob classified as %s=%g, delta=%g) at:", str.string(),
cert, cert - target_cert);
ol_box.print();
}
if (cert > best_cert) {
best_cert = cert;
best_index = i;
best_outlines = test_outlines;
}
test_outlines[i] = true;
}
}
if (best_index >= 0) {
test_outlines[best_index] = false;
--num_outlines;
}
}
if (best_cert >= target_cert) {
// Save the best combination.
*ok_outlines = best_outlines;
if (debug_noise_removal) {
tprintf("%s noise combination ", blob ? "Adding" : "New");
for (int i = 0; i < best_outlines.size(); ++i) {
tprintf("%d", best_outlines[i]);
}
tprintf(" yields certainty %g, beating target of %g\n", best_cert,
target_cert);
}
return true;
}
return false;
}
// Classifies the given blob plus the outlines flagged by ok_outlines, undoes
// the inclusion of the outlines, and returns the certainty of the raw choice.
float Tesseract::ClassifyBlobPlusOutlines(
const GenericVector<bool>& ok_outlines,
const GenericVector<C_OUTLINE*>& outlines, int pass_n, PAGE_RES_IT* pr_it,
C_BLOB* blob, STRING* best_str) {
C_OUTLINE_IT ol_it;
C_OUTLINE* first_to_keep = NULL;
if (blob != NULL) {
// Add the required outlines to the blob.
ol_it.set_to_list(blob->out_list());
first_to_keep = ol_it.data();
}
for (int i = 0; i < ok_outlines.size(); ++i) {
if (ok_outlines[i]) {
// This outline is to be added.
if (blob == NULL) {
blob = new C_BLOB(outlines[i]);
ol_it.set_to_list(blob->out_list());
} else {
ol_it.add_before_stay_put(outlines[i]);
}
}
}
float c2;
float cert = ClassifyBlobAsWord(pass_n, pr_it, blob, best_str, &c2);
ol_it.move_to_first();
if (first_to_keep == NULL) {
// We created blob. Empty its outlines and delete it.
for (; !ol_it.empty(); ol_it.forward()) ol_it.extract();
delete blob;
cert = -c2;
} else {
// Remove the outlines that we put in.
for (; ol_it.data() != first_to_keep; ol_it.forward()) {
ol_it.extract();
}
}
return cert;
}
// Classifies the given blob (part of word_data->word->word) as an individual
// word, using languages, chopper etc, returning only the certainty of the
// best raw choice, and undoing all the work done to fake out the word.
float Tesseract::ClassifyBlobAsWord(int pass_n, PAGE_RES_IT* pr_it,
C_BLOB* blob, STRING* best_str, float* c2) {
WERD* real_word = pr_it->word()->word;
WERD* word = real_word->ConstructFromSingleBlob(
real_word->flag(W_BOL), real_word->flag(W_EOL), C_BLOB::deep_copy(blob));
WERD_RES* word_res = pr_it->InsertSimpleCloneWord(*pr_it->word(), word);
// Get a new iterator that points to the new word.
PAGE_RES_IT it(pr_it->page_res);
while (it.word() != word_res && it.word() != NULL) it.forward();
ASSERT_HOST(it.word() == word_res);
WordData wd(it);
// Force full initialization.
SetupWordPassN(1, &wd);
classify_word_and_language(pass_n, &it, &wd);
if (debug_noise_removal) {
tprintf("word xheight=%g, row=%g, range=[%g,%g]\n", word_res->x_height,
wd.row->x_height(), wd.word->raw_choice->min_x_height(),
wd.word->raw_choice->max_x_height());
}
float cert = wd.word->raw_choice->certainty();
float rat = wd.word->raw_choice->rating();
*c2 = rat > 0.0f ? cert * cert / rat : 0.0f;
*best_str = wd.word->raw_choice->unichar_string();
it.DeleteCurrentWord();
pr_it->ResetWordIterator();
return cert;
}
// Generic function for classifying a word. Can be used either for pass1 or
// pass2 according to the function passed to recognizer.
// word_data holds the word to be recognized, and its block and row, and
// pr_it points to the word as well, in case we are running LSTM and it wants
// to output multiple words.
// Recognizes in the current language, and if successful that is all.
// If recognition was not successful, tries all available languages until
// it gets a successful result or runs out of languages. Keeps the best result.
void Tesseract::classify_word_and_language(int pass_n, PAGE_RES_IT* pr_it,
WordData* word_data) {
WordRecognizer recognizer = pass_n == 1 ? &Tesseract::classify_word_pass1
: &Tesseract::classify_word_pass2;
// Best result so far.
PointerVector<WERD_RES> best_words;
// Points to the best result. May be word or in lang_words.
WERD_RES* word = word_data->word;
clock_t start_t = clock();
if (classify_debug_level || cube_debug_level) {
tprintf("%s word with lang %s at:",
word->done ? "Already done" : "Processing",
most_recently_used_->lang.string());
word->word->bounding_box().print();
}
if (word->done) {
// If done on pass1, leave it as-is.
if (!word->tess_failed)
most_recently_used_ = word->tesseract;
return;
}
int sub = sub_langs_.size();
if (most_recently_used_ != this) {
// Get the index of the most_recently_used_.
for (sub = 0; sub < sub_langs_.size() &&
most_recently_used_ != sub_langs_[sub]; ++sub) {}
}
most_recently_used_->RetryWithLanguage(
*word_data, recognizer, &word_data->lang_words[sub], &best_words);
Tesseract* best_lang_tess = most_recently_used_;
if (!WordsAcceptable(best_words)) {
// Try all the other languages to see if they are any better.
if (most_recently_used_ != this &&
this->RetryWithLanguage(*word_data, recognizer,
&word_data->lang_words[sub_langs_.size()],
&best_words) > 0) {
best_lang_tess = this;
}
for (int i = 0; !WordsAcceptable(best_words) && i < sub_langs_.size();
++i) {
if (most_recently_used_ != sub_langs_[i] &&
sub_langs_[i]->RetryWithLanguage(*word_data, recognizer,
&word_data->lang_words[i],
&best_words) > 0) {
best_lang_tess = sub_langs_[i];
}
}
}
most_recently_used_ = best_lang_tess;
if (!best_words.empty()) {
if (best_words.size() == 1 && !best_words[0]->combination) {
// Move the best single result to the main word.
word_data->word->ConsumeWordResults(best_words[0]);
} else {
// Words came from LSTM, and must be moved to the PAGE_RES properly.
word_data->word = best_words.back();
pr_it->ReplaceCurrentWord(&best_words);
}
ASSERT_HOST(word_data->word->box_word != NULL);
} else {
tprintf("no best words!!\n");
}
clock_t ocr_t = clock();
if (tessedit_timing_debug) {
tprintf("%s (ocr took %.2f sec)\n",
word->best_choice->unichar_string().string(),
static_cast<double>(ocr_t-start_t)/CLOCKS_PER_SEC);
}
}
/**
* classify_word_pass1
*
* Baseline normalize the word and pass it to Tess.
*/
void Tesseract::classify_word_pass1(const WordData& word_data,
WERD_RES** in_word,
PointerVector<WERD_RES>* out_words) {
ROW* row = word_data.row;
BLOCK* block = word_data.block;
prev_word_best_choice_ = word_data.prev_word != NULL
? word_data.prev_word->word->best_choice : NULL;
#ifndef NO_CUBE_BUILD
// If we only intend to run cube - run it and return.
if (tessedit_ocr_engine_mode == OEM_CUBE_ONLY) {
cube_word_pass1(block, row, *in_word);
return;
}
#endif
WERD_RES* word = *in_word;
match_word_pass_n(1, word, row, block);
if (!word->tess_failed && !word->word->flag(W_REP_CHAR)) {
word->tess_would_adapt = AdaptableWord(word);
bool adapt_ok = word_adaptable(word, tessedit_tess_adaption_mode);
if (adapt_ok) {
// Send word to adaptive classifier for training.
word->BestChoiceToCorrectText();
LearnWord(NULL, word);
// Mark misadaptions if running blamer.
if (word->blamer_bundle != NULL) {
word->blamer_bundle->SetMisAdaptionDebug(word->best_choice,
wordrec_debug_blamer);
}
}
if (tessedit_enable_doc_dict && !word->IsAmbiguous())
tess_add_doc_word(word->best_choice);
}
}
// Helper to report the result of the xheight fix.
void Tesseract::ReportXhtFixResult(bool accept_new_word, float new_x_ht,
WERD_RES* word, WERD_RES* new_word) {
tprintf("New XHT Match:%s = %s ",
word->best_choice->unichar_string().string(),
word->best_choice->debug_string().string());
word->reject_map.print(debug_fp);
tprintf(" -> %s = %s ",
new_word->best_choice->unichar_string().string(),
new_word->best_choice->debug_string().string());
new_word->reject_map.print(debug_fp);
tprintf(" %s->%s %s %s\n",
word->guessed_x_ht ? "GUESS" : "CERT",
new_word->guessed_x_ht ? "GUESS" : "CERT",
new_x_ht > 0.1 ? "STILL DOUBT" : "OK",
accept_new_word ? "ACCEPTED" : "");
}
// Run the x-height fix-up, based on min/max top/bottom information in
// unicharset.
// Returns true if the word was changed.
// See the comment in fixxht.cpp for a description of the overall process.
bool Tesseract::TrainedXheightFix(WERD_RES *word, BLOCK* block, ROW *row) {
int original_misfits = CountMisfitTops(word);
if (original_misfits == 0)
return false;
float baseline_shift = 0.0f;
float new_x_ht = ComputeCompatibleXheight(word, &baseline_shift);
if (baseline_shift != 0.0f) {
// Try the shift on its own first.
if (!TestNewNormalization(original_misfits, baseline_shift, word->x_height,
word, block, row))
return false;
original_misfits = CountMisfitTops(word);
if (original_misfits > 0) {
float new_baseline_shift;
// Now recompute the new x_height.
new_x_ht = ComputeCompatibleXheight(word, &new_baseline_shift);
if (new_x_ht >= kMinRefitXHeightFraction * word->x_height) {
// No test of return value here, as we are definitely making a change
// to the word by shifting the baseline.
TestNewNormalization(original_misfits, baseline_shift, new_x_ht,
word, block, row);
}
}
return true;
} else if (new_x_ht >= kMinRefitXHeightFraction * word->x_height) {
return TestNewNormalization(original_misfits, 0.0f, new_x_ht,
word, block, row);
} else {
return false;
}
}
// Runs recognition with the test baseline shift and x-height and returns true
// if there was an improvement in recognition result.
bool Tesseract::TestNewNormalization(int original_misfits,
float baseline_shift, float new_x_ht,
WERD_RES *word, BLOCK* block, ROW *row) {
bool accept_new_x_ht = false;
WERD_RES new_x_ht_word(word->word);
if (word->blamer_bundle != NULL) {
new_x_ht_word.blamer_bundle = new BlamerBundle();
new_x_ht_word.blamer_bundle->CopyTruth(*(word->blamer_bundle));
}
new_x_ht_word.x_height = new_x_ht;
new_x_ht_word.baseline_shift = baseline_shift;
new_x_ht_word.caps_height = 0.0;
new_x_ht_word.SetupForRecognition(
unicharset, this, BestPix(), tessedit_ocr_engine_mode, NULL,
classify_bln_numeric_mode, textord_use_cjk_fp_model,
poly_allow_detailed_fx, row, block);
match_word_pass_n(2, &new_x_ht_word, row, block);
if (!new_x_ht_word.tess_failed) {
int new_misfits = CountMisfitTops(&new_x_ht_word);
if (debug_x_ht_level >= 1) {
tprintf("Old misfits=%d with x-height %f, new=%d with x-height %f\n",
original_misfits, word->x_height,
new_misfits, new_x_ht);
tprintf("Old rating= %f, certainty=%f, new=%f, %f\n",
word->best_choice->rating(), word->best_choice->certainty(),
new_x_ht_word.best_choice->rating(),
new_x_ht_word.best_choice->certainty());
}
// The misfits must improve and either the rating or certainty.
accept_new_x_ht = new_misfits < original_misfits &&
(new_x_ht_word.best_choice->certainty() >
word->best_choice->certainty() ||
new_x_ht_word.best_choice->rating() <
word->best_choice->rating());
if (debug_x_ht_level >= 1) {
ReportXhtFixResult(accept_new_x_ht, new_x_ht, word, &new_x_ht_word);
}
}
if (accept_new_x_ht) {
word->ConsumeWordResults(&new_x_ht_word);
return true;
}
return false;
}
/**
* classify_word_pass2
*
* Control what to do with the word in pass 2
*/
void Tesseract::classify_word_pass2(const WordData& word_data,
WERD_RES** in_word,
PointerVector<WERD_RES>* out_words) {
// Return if we do not want to run Tesseract.
if (tessedit_ocr_engine_mode != OEM_TESSERACT_ONLY &&
tessedit_ocr_engine_mode != OEM_TESSERACT_CUBE_COMBINED &&
word_data.word->best_choice != NULL)
return;
if (tessedit_ocr_engine_mode == OEM_CUBE_ONLY) {
return;
}
ROW* row = word_data.row;
BLOCK* block = word_data.block;
WERD_RES* word = *in_word;
prev_word_best_choice_ = word_data.prev_word != NULL
? word_data.prev_word->word->best_choice : NULL;
set_global_subloc_code(SUBLOC_NORM);
check_debug_pt(word, 30);
if (!word->done) {
word->caps_height = 0.0;
if (word->x_height == 0.0f)
word->x_height = row->x_height();
match_word_pass_n(2, word, row, block);
check_debug_pt(word, 40);
}
SubAndSuperscriptFix(word);
if (!word->tess_failed && !word->word->flag(W_REP_CHAR)) {
if (unicharset.top_bottom_useful() && unicharset.script_has_xheight() &&
block->classify_rotation().y() == 0.0f) {
// Use the tops and bottoms since they are available.
TrainedXheightFix(word, block, row);
}
set_global_subloc_code(SUBLOC_NORM);
}
#ifndef GRAPHICS_DISABLED
if (tessedit_display_outwords) {
if (fx_win == NULL)
create_fx_win();
clear_fx_win();
word->rebuild_word->plot(fx_win);
TBOX wbox = word->rebuild_word->bounding_box();
fx_win->ZoomToRectangle(wbox.left(), wbox.top(),
wbox.right(), wbox.bottom());
ScrollView::Update();
}
#endif
set_global_subloc_code(SUBLOC_NORM);
check_debug_pt(word, 50);
}
/**
* match_word_pass2
*
* Baseline normalize the word and pass it to Tess.
*/
void Tesseract::match_word_pass_n(int pass_n, WERD_RES *word,
ROW *row, BLOCK* block) {
if (word->tess_failed) return;
tess_segment_pass_n(pass_n, word);
if (!word->tess_failed) {
if (!word->word->flag (W_REP_CHAR)) {
word->fix_quotes();
if (tessedit_fix_hyphens)
word->fix_hyphens();
/* Don't trust fix_quotes! - though I think I've fixed the bug */
if (word->best_choice->length() != word->box_word->length()) {
tprintf("POST FIX_QUOTES FAIL String:\"%s\"; Strlen=%d;"
" #Blobs=%d\n",
word->best_choice->debug_string().string(),
word->best_choice->length(),
word->box_word->length());
}
word->tess_accepted = tess_acceptable_word(word);
// Also sets word->done flag
make_reject_map(word, row, pass_n);
}
}
set_word_fonts(word);
ASSERT_HOST(word->raw_choice != NULL);
}
// Helper to return the best rated BLOB_CHOICE in the whole word that matches
// the given char_id, or NULL if none can be found.
static BLOB_CHOICE* FindBestMatchingChoice(UNICHAR_ID char_id,
WERD_RES* word_res) {
// Find the corresponding best BLOB_CHOICE from any position in the word_res.
BLOB_CHOICE* best_choice = NULL;
for (int i = 0; i < word_res->best_choice->length(); ++i) {
BLOB_CHOICE* choice = FindMatchingChoice(char_id,
word_res->GetBlobChoices(i));
if (choice != NULL) {
if (best_choice == NULL || choice->rating() < best_choice->rating())
best_choice = choice;
}
}
return best_choice;
}
// Helper to insert blob_choice in each location in the leader word if there is
// no matching BLOB_CHOICE there already, and correct any incorrect results
// in the best_choice.
static void CorrectRepcharChoices(BLOB_CHOICE* blob_choice,
WERD_RES* word_res) {
WERD_CHOICE* word = word_res->best_choice;
for (int i = 0; i < word_res->best_choice->length(); ++i) {
BLOB_CHOICE* choice = FindMatchingChoice(blob_choice->unichar_id(),
word_res->GetBlobChoices(i));
if (choice == NULL) {
BLOB_CHOICE_IT choice_it(word_res->GetBlobChoices(i));
choice_it.add_before_stay_put(new BLOB_CHOICE(*blob_choice));
}
}
// Correct any incorrect results in word.
for (int i = 0; i < word->length(); ++i) {
if (word->unichar_id(i) != blob_choice->unichar_id())
word->set_unichar_id(blob_choice->unichar_id(), i);
}
}
/**
* fix_rep_char()
* The word is a repeated char. (Leader.) Find the repeated char character.
* Create the appropriate single-word or multi-word sequence according to
* the size of spaces in between blobs, and correct the classifications
* where some of the characters disagree with the majority.
*/
void Tesseract::fix_rep_char(PAGE_RES_IT* page_res_it) {
WERD_RES *word_res = page_res_it->word();
const WERD_CHOICE &word = *(word_res->best_choice);
// Find the frequency of each unique character in the word.
SortHelper<UNICHAR_ID> rep_ch(word.length());
for (int i = 0; i < word.length(); ++i) {
rep_ch.Add(word.unichar_id(i), 1);
}
// Find the most frequent result.
UNICHAR_ID maxch_id = INVALID_UNICHAR_ID; // most common char
int max_count = rep_ch.MaxCount(&maxch_id);
// Find the best exemplar of a classifier result for maxch_id.
BLOB_CHOICE* best_choice = FindBestMatchingChoice(maxch_id, word_res);
if (best_choice == NULL) {
tprintf("Failed to find a choice for %s, occurring %d times\n",
word_res->uch_set->debug_str(maxch_id).string(), max_count);
return;
}
word_res->done = TRUE;
// Measure the mean space.
int gap_count = 0;
WERD* werd = word_res->word;
C_BLOB_IT blob_it(werd->cblob_list());
C_BLOB* prev_blob = blob_it.data();
for (blob_it.forward(); !blob_it.at_first(); blob_it.forward()) {
C_BLOB* blob = blob_it.data();
int gap = blob->bounding_box().left();
gap -= prev_blob->bounding_box().right();
++gap_count;
prev_blob = blob;
}
// Just correct existing classification.
CorrectRepcharChoices(best_choice, word_res);
word_res->reject_map.initialise(word.length());
}
ACCEPTABLE_WERD_TYPE Tesseract::acceptable_word_string(
const UNICHARSET& char_set, const char *s, const char *lengths) {
int i = 0;
int offset = 0;
int leading_punct_count;
int upper_count = 0;
int hyphen_pos = -1;
ACCEPTABLE_WERD_TYPE word_type = AC_UNACCEPTABLE;
if (strlen (lengths) > 20)
return word_type;
/* Single Leading punctuation char*/
if (s[offset] != '\0' && STRING(chs_leading_punct).contains(s[offset]))
offset += lengths[i++];
leading_punct_count = i;
/* Initial cap */
while (s[offset] != '\0' && char_set.get_isupper(s + offset, lengths[i])) {
offset += lengths[i++];
upper_count++;
}
if (upper_count > 1) {
word_type = AC_UPPER_CASE;
} else {
/* Lower case word, possibly with an initial cap */
while (s[offset] != '\0' && char_set.get_islower(s + offset, lengths[i])) {
offset += lengths[i++];
}
if (i - leading_punct_count < quality_min_initial_alphas_reqd)
goto not_a_word;
/*
Allow a single hyphen in a lower case word
- don't trust upper case - I've seen several cases of "H" -> "I-I"
*/
if (lengths[i] == 1 && s[offset] == '-') {
hyphen_pos = i;
offset += lengths[i++];
if (s[offset] != '\0') {
while ((s[offset] != '\0') &&
char_set.get_islower(s + offset, lengths[i])) {
offset += lengths[i++];
}
if (i < hyphen_pos + 3)
goto not_a_word;
}
} else {
/* Allow "'s" in NON hyphenated lower case words */
if (lengths[i] == 1 && (s[offset] == '\'') &&
lengths[i + 1] == 1 && (s[offset + lengths[i]] == 's')) {
offset += lengths[i++];
offset += lengths[i++];
}
}
if (upper_count > 0)
word_type = AC_INITIAL_CAP;
else
word_type = AC_LOWER_CASE;
}
/* Up to two different, constrained trailing punctuation chars */
if (lengths[i] == 1 && s[offset] != '\0' &&
STRING(chs_trailing_punct1).contains(s[offset]))
offset += lengths[i++];
if (lengths[i] == 1 && s[offset] != '\0' && i > 0 &&
s[offset - lengths[i - 1]] != s[offset] &&
STRING(chs_trailing_punct2).contains (s[offset]))
offset += lengths[i++];
if (s[offset] != '\0')
word_type = AC_UNACCEPTABLE;
not_a_word:
if (word_type == AC_UNACCEPTABLE) {
/* Look for abbreviation string */
i = 0;
offset = 0;
if (s[0] != '\0' && char_set.get_isupper(s, lengths[0])) {
word_type = AC_UC_ABBREV;
while (s[offset] != '\0' &&
char_set.get_isupper(s + offset, lengths[i]) &&
lengths[i + 1] == 1 && s[offset + lengths[i]] == '.') {
offset += lengths[i++];
offset += lengths[i++];
}
}
else if (s[0] != '\0' && char_set.get_islower(s, lengths[0])) {
word_type = AC_LC_ABBREV;
while (s[offset] != '\0' &&
char_set.get_islower(s + offset, lengths[i]) &&
lengths[i + 1] == 1 && s[offset + lengths[i]] == '.') {
offset += lengths[i++];
offset += lengths[i++];
}
}
if (s[offset] != '\0')
word_type = AC_UNACCEPTABLE;
}
return word_type;
}
BOOL8 Tesseract::check_debug_pt(WERD_RES *word, int location) {
BOOL8 show_map_detail = FALSE;
inT16 i;
if (!test_pt)
return FALSE;
tessedit_rejection_debug.set_value (FALSE);
debug_x_ht_level.set_value(0);
if (word->word->bounding_box ().contains (FCOORD (test_pt_x, test_pt_y))) {
if (location < 0)
return TRUE; // For breakpoint use
tessedit_rejection_debug.set_value (TRUE);
debug_x_ht_level.set_value(2);
tprintf ("\n\nTESTWD::");
switch (location) {
case 0:
tprintf ("classify_word_pass1 start\n");
word->word->print();
break;
case 10:
tprintf ("make_reject_map: initial map");
break;
case 20:
tprintf ("make_reject_map: after NN");
break;
case 30:
tprintf ("classify_word_pass2 - START");
break;
case 40:
tprintf ("classify_word_pass2 - Pre Xht");
break;
case 50:
tprintf ("classify_word_pass2 - END");
show_map_detail = TRUE;
break;
case 60:
tprintf ("fixspace");
break;
case 70:
tprintf ("MM pass START");
break;
case 80:
tprintf ("MM pass END");
break;
case 90:
tprintf ("After Poor quality rejection");
break;
case 100:
tprintf ("unrej_good_quality_words - START");
break;
case 110:
tprintf ("unrej_good_quality_words - END");
break;
case 120:
tprintf ("Write results pass");
show_map_detail = TRUE;
break;
}
if (word->best_choice != NULL) {
tprintf(" \"%s\" ", word->best_choice->unichar_string().string());
word->reject_map.print(debug_fp);
tprintf("\n");
if (show_map_detail) {
tprintf("\"%s\"\n", word->best_choice->unichar_string().string());
for (i = 0; word->best_choice->unichar_string()[i] != '\0'; i++) {
tprintf("**** \"%c\" ****\n", word->best_choice->unichar_string()[i]);
word->reject_map[i].full_print(debug_fp);
}
}
} else {
tprintf("null best choice\n");
}
tprintf ("Tess Accepted: %s\n", word->tess_accepted ? "TRUE" : "FALSE");
tprintf ("Done flag: %s\n\n", word->done ? "TRUE" : "FALSE");
return TRUE;
} else {
return FALSE;
}
}
/**
* find_modal_font
*
* Find the modal font and remove from the stats.
*/
static void find_modal_font( //good chars in word
STATS *fonts, //font stats
inT16 *font_out, //output font
inT8 *font_count //output count
) {
inT16 font; //font index
inT32 count; //pile couat
if (fonts->get_total () > 0) {
font = (inT16) fonts->mode ();
*font_out = font;
count = fonts->pile_count (font);
*font_count = count < MAX_INT8 ? count : MAX_INT8;
fonts->add (font, -*font_count);
}
else {
*font_out = -1;
*font_count = 0;
}
}
/**
* set_word_fonts
*
* Get the fonts for the word.
*/
void Tesseract::set_word_fonts(WERD_RES *word) {
// Don't try to set the word fonts for a cube word, as the configs
// will be meaningless.
if (word->chopped_word == NULL) return;
ASSERT_HOST(word->best_choice != NULL);
int fontinfo_size = get_fontinfo_table().size();
if (fontinfo_size == 0) return;
GenericVector<int> font_total_score;
font_total_score.init_to_size(fontinfo_size, 0);
word->italic = 0;
word->bold = 0;
// Compute the font scores for the word
if (tessedit_debug_fonts) {
tprintf("Examining fonts in %s\n",
word->best_choice->debug_string().string());
}
for (int b = 0; b < word->best_choice->length(); ++b) {
BLOB_CHOICE* choice = word->GetBlobChoice(b);
if (choice == NULL) continue;
const GenericVector<ScoredFont>& fonts = choice->fonts();
for (int f = 0; f < fonts.size(); ++f) {
int fontinfo_id = fonts[f].fontinfo_id;
if (0 <= fontinfo_id && fontinfo_id < fontinfo_size) {
font_total_score[fontinfo_id] += fonts[f].score;
}
}
}
// Find the top and 2nd choice for the word.
int score1 = 0, score2 = 0;
inT16 font_id1 = -1, font_id2 = -1;
for (int f = 0; f < fontinfo_size; ++f) {
if (tessedit_debug_fonts && font_total_score[f] > 0) {
tprintf("Font %s, total score = %d\n",
fontinfo_table_.get(f).name, font_total_score[f]);
}
if (font_total_score[f] > score1) {
score2 = score1;
font_id2 = font_id1;
score1 = font_total_score[f];
font_id1 = f;
} else if (font_total_score[f] > score2) {
score2 = font_total_score[f];
font_id2 = f;
}
}
word->fontinfo = font_id1 >= 0 ? &fontinfo_table_.get(font_id1) : NULL;
word->fontinfo2 = font_id2 >= 0 ? &fontinfo_table_.get(font_id2) : NULL;
// Each score has a limit of MAX_UINT16, so divide by that to get the number
// of "votes" for that font, ie number of perfect scores.
word->fontinfo_id_count = ClipToRange(score1 / MAX_UINT16, 1, MAX_INT8);
word->fontinfo_id2_count = ClipToRange(score2 / MAX_UINT16, 0, MAX_INT8);
if (score1 > 0) {
FontInfo fi = fontinfo_table_.get(font_id1);
if (tessedit_debug_fonts) {
if (word->fontinfo_id2_count > 0) {
tprintf("Word modal font=%s, score=%d, 2nd choice %s/%d\n",
fi.name, word->fontinfo_id_count,
fontinfo_table_.get(font_id2).name,
word->fontinfo_id2_count);
} else {
tprintf("Word modal font=%s, score=%d. No 2nd choice\n",
fi.name, word->fontinfo_id_count);
}
}
word->italic = (fi.is_italic() ? 1 : -1) * word->fontinfo_id_count;
word->bold = (fi.is_bold() ? 1 : -1) * word->fontinfo_id_count;
}
}
/**
* font_recognition_pass
*
* Smooth the fonts for the document.
*/
void Tesseract::font_recognition_pass(PAGE_RES* page_res) {
PAGE_RES_IT page_res_it(page_res);
WERD_RES *word; // current word
STATS doc_fonts(0, font_table_size_); // font counters
// Gather font id statistics.
for (page_res_it.restart_page(); page_res_it.word() != NULL;
page_res_it.forward()) {
word = page_res_it.word();
if (word->fontinfo != NULL) {
doc_fonts.add(word->fontinfo->universal_id, word->fontinfo_id_count);
}
if (word->fontinfo2 != NULL) {
doc_fonts.add(word->fontinfo2->universal_id, word->fontinfo_id2_count);
}
}
inT16 doc_font; // modal font
inT8 doc_font_count; // modal font
find_modal_font(&doc_fonts, &doc_font, &doc_font_count);
if (doc_font_count == 0)
return;
// Get the modal font pointer.
const FontInfo* modal_font = NULL;
for (page_res_it.restart_page(); page_res_it.word() != NULL;
page_res_it.forward()) {
word = page_res_it.word();
if (word->fontinfo != NULL && word->fontinfo->universal_id == doc_font) {
modal_font = word->fontinfo;
break;
}
if (word->fontinfo2 != NULL && word->fontinfo2->universal_id == doc_font) {
modal_font = word->fontinfo2;
break;
}
}
ASSERT_HOST(modal_font != NULL);
// Assign modal font to weak words.
for (page_res_it.restart_page(); page_res_it.word() != NULL;
page_res_it.forward()) {
word = page_res_it.word();
int length = word->best_choice->length();
int count = word->fontinfo_id_count;
if (!(count == length || (length > 3 && count >= length * 3 / 4))) {
word->fontinfo = modal_font;
// Counts only get 1 as it came from the doc.
word->fontinfo_id_count = 1;
word->italic = modal_font->is_italic() ? 1 : -1;
word->bold = modal_font->is_bold() ? 1 : -1;
}
}
}
// If a word has multiple alternates check if the best choice is in the
// dictionary. If not, replace it with an alternate that exists in the
// dictionary.
void Tesseract::dictionary_correction_pass(PAGE_RES *page_res) {
PAGE_RES_IT word_it(page_res);
for (WERD_RES* word = word_it.word(); word != NULL;
word = word_it.forward()) {
if (word->best_choices.singleton())
continue; // There are no alternates.
WERD_CHOICE* best = word->best_choice;
if (word->tesseract->getDict().valid_word(*best) != 0)
continue; // The best choice is in the dictionary.
WERD_CHOICE_IT choice_it(&word->best_choices);
for (choice_it.mark_cycle_pt(); !choice_it.cycled_list();
choice_it.forward()) {
WERD_CHOICE* alternate = choice_it.data();
if (word->tesseract->getDict().valid_word(*alternate)) {
// The alternate choice is in the dictionary.
if (tessedit_bigram_debug) {
tprintf("Dictionary correction replaces best choice '%s' with '%s'\n",
best->unichar_string().string(),
alternate->unichar_string().string());
}
// Replace the 'best' choice with a better choice.
word->ReplaceBestChoice(alternate);
break;
}
}
}
}
} // namespace tesseract
| [
"renard.wellnitz@googlemail.com"
] | renard.wellnitz@googlemail.com |
bd549e9d8e6ee943b238e7fc24b2ab30b4883378 | 7884406966bd0b51dc3fe1eebbea2db9f9035e43 | /buildtools/msys32/usr/lib/gcc/i686-pc-msys/7.3.0/include/c++/bits/locale_conv.h | bf8680372163aa7fa6287be3c78ea672a3cbf3f0 | [] | no_license | nguyenhtm/espt | 788778057dd07fe9cbe16c9c493e118d1dbc1b9b | 63692b7e87c14e3ced7cf0d6bfd541b1eeaf2460 | refs/heads/master | 2021-09-20T13:02:54.161699 | 2020-10-04T10:30:20 | 2020-10-04T10:30:20 | 223,217,602 | 1 | 1 | null | 2021-08-02T17:05:22 | 2019-11-21T16:31:49 | C | UTF-8 | C++ | false | false | 16,087 | h | // wstring_convert implementation -*- C++ -*-
// Copyright (C) 2015-2017 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file bits/locale_conv.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{locale}
*/
#ifndef _LOCALE_CONV_H
#define _LOCALE_CONV_H 1
#if __cplusplus < 201103L
# include <bits/c++0x_warning.h>
#else
#include <streambuf>
#include "stringfwd.h"
#include "allocator.h"
#include "codecvt.h"
#include "unique_ptr.h"
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup locales
* @{
*/
template<typename _OutStr, typename _InChar, typename _Codecvt,
typename _State, typename _Fn>
bool
__do_str_codecvt(const _InChar* __first, const _InChar* __last,
_OutStr& __outstr, const _Codecvt& __cvt, _State& __state,
size_t& __count, _Fn __fn)
{
if (__first == __last)
{
__outstr.clear();
__count = 0;
return true;
}
size_t __outchars = 0;
auto __next = __first;
const auto __maxlen = __cvt.max_length() + 1;
codecvt_base::result __result;
do
{
__outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
auto __outnext = &__outstr.front() + __outchars;
auto const __outlast = &__outstr.back() + 1;
__result = (__cvt.*__fn)(__state, __next, __last, __next,
__outnext, __outlast, __outnext);
__outchars = __outnext - &__outstr.front();
}
while (__result == codecvt_base::partial && __next != __last
&& (__outstr.size() - __outchars) < __maxlen);
if (__result == codecvt_base::error)
{
__count = __next - __first;
return false;
}
if (__result == codecvt_base::noconv)
{
__outstr.assign(__first, __last);
__count = __last - __first;
}
else
{
__outstr.resize(__outchars);
__count = __next - __first;
}
return true;
}
// Convert narrow character string to wide.
template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
inline bool
__str_codecvt_in(const char* __first, const char* __last,
basic_string<_CharT, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt,
_State& __state, size_t& __count)
{
using _Codecvt = codecvt<_CharT, char, _State>;
using _ConvFn
= codecvt_base::result
(_Codecvt::*)(_State&, const char*, const char*, const char*&,
_CharT*, _CharT*, _CharT*&) const;
_ConvFn __fn = &codecvt<_CharT, char, _State>::in;
return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
__count, __fn);
}
template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
inline bool
__str_codecvt_in(const char* __first, const char* __last,
basic_string<_CharT, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt)
{
_State __state = {};
size_t __n;
return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
}
// Convert wide character string to narrow.
template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
inline bool
__str_codecvt_out(const _CharT* __first, const _CharT* __last,
basic_string<char, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt,
_State& __state, size_t& __count)
{
using _Codecvt = codecvt<_CharT, char, _State>;
using _ConvFn
= codecvt_base::result
(_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
char*, char*, char*&) const;
_ConvFn __fn = &codecvt<_CharT, char, _State>::out;
return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
__count, __fn);
}
template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
inline bool
__str_codecvt_out(const _CharT* __first, const _CharT* __last,
basic_string<char, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt)
{
_State __state = {};
size_t __n;
return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
}
#ifdef _GLIBCXX_USE_WCHAR_T
_GLIBCXX_BEGIN_NAMESPACE_CXX11
/// String conversions
template<typename _Codecvt, typename _Elem = wchar_t,
typename _Wide_alloc = allocator<_Elem>,
typename _Byte_alloc = allocator<char>>
class wstring_convert
{
public:
typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
typedef typename _Codecvt::state_type state_type;
typedef typename wide_string::traits_type::int_type int_type;
/** Default constructor.
*
* @param __pcvt The facet to use for conversions.
*
* Takes ownership of @p __pcvt and will delete it in the destructor.
*/
explicit
wstring_convert(_Codecvt* __pcvt = new _Codecvt()) : _M_cvt(__pcvt)
{
if (!_M_cvt)
__throw_logic_error("wstring_convert");
}
/** Construct with an initial converstion state.
*
* @param __pcvt The facet to use for conversions.
* @param __state Initial conversion state.
*
* Takes ownership of @p __pcvt and will delete it in the destructor.
* The object's conversion state will persist between conversions.
*/
wstring_convert(_Codecvt* __pcvt, state_type __state)
: _M_cvt(__pcvt), _M_state(__state), _M_with_cvtstate(true)
{
if (!_M_cvt)
__throw_logic_error("wstring_convert");
}
/** Construct with error strings.
*
* @param __byte_err A string to return on failed conversions.
* @param __wide_err A wide string to return on failed conversions.
*/
explicit
wstring_convert(const byte_string& __byte_err,
const wide_string& __wide_err = wide_string())
: _M_cvt(new _Codecvt),
_M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
_M_with_strings(true)
{
if (!_M_cvt)
__throw_logic_error("wstring_convert");
}
~wstring_convert() = default;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2176. Special members for wstring_convert and wbuffer_convert
wstring_convert(const wstring_convert&) = delete;
wstring_convert& operator=(const wstring_convert&) = delete;
/// @{ Convert from bytes.
wide_string
from_bytes(char __byte)
{
char __bytes[2] = { __byte };
return from_bytes(__bytes, __bytes+1);
}
wide_string
from_bytes(const char* __ptr)
{ return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }
wide_string
from_bytes(const byte_string& __str)
{
auto __ptr = __str.data();
return from_bytes(__ptr, __ptr + __str.size());
}
wide_string
from_bytes(const char* __first, const char* __last)
{
if (!_M_with_cvtstate)
_M_state = state_type();
wide_string ___out{ _M_wide_err_string.get_allocator() };
if (__str_codecvt_in(__first, __last, ___out, *_M_cvt, _M_state,
_M_count))
return ___out;
if (_M_with_strings)
return _M_wide_err_string;
__throw_range_error("wstring_convert::from_bytes");
}
/// @}
/// @{ Convert to bytes.
byte_string
to_bytes(_Elem __wchar)
{
_Elem __wchars[2] = { __wchar };
return to_bytes(__wchars, __wchars+1);
}
byte_string
to_bytes(const _Elem* __ptr)
{
return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
}
byte_string
to_bytes(const wide_string& __wstr)
{
auto __ptr = __wstr.data();
return to_bytes(__ptr, __ptr + __wstr.size());
}
byte_string
to_bytes(const _Elem* __first, const _Elem* __last)
{
if (!_M_with_cvtstate)
_M_state = state_type();
byte_string ___out{ _M_byte_err_string.get_allocator() };
if (__str_codecvt_out(__first, __last, ___out, *_M_cvt, _M_state,
_M_count))
return ___out;
if (_M_with_strings)
return _M_byte_err_string;
__throw_range_error("wstring_convert::to_bytes");
}
/// @}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2174. wstring_convert::converted() should be noexcept
/// The number of elements successfully converted in the last conversion.
size_t converted() const noexcept { return _M_count; }
/// The final conversion state of the last conversion.
state_type state() const { return _M_state; }
private:
unique_ptr<_Codecvt> _M_cvt;
byte_string _M_byte_err_string;
wide_string _M_wide_err_string;
state_type _M_state = state_type();
size_t _M_count = 0;
bool _M_with_cvtstate = false;
bool _M_with_strings = false;
};
_GLIBCXX_END_NAMESPACE_CXX11
/// Buffer conversions
template<typename _Codecvt, typename _Elem = wchar_t,
typename _Tr = char_traits<_Elem>>
class wbuffer_convert : public basic_streambuf<_Elem, _Tr>
{
typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf;
public:
typedef typename _Codecvt::state_type state_type;
/** Default constructor.
*
* @param __bytebuf The underlying byte stream buffer.
* @param __pcvt The facet to use for conversions.
* @param __state Initial conversion state.
*
* Takes ownership of @p __pcvt and will delete it in the destructor.
*/
explicit
wbuffer_convert(streambuf* __bytebuf = 0, _Codecvt* __pcvt = new _Codecvt,
state_type __state = state_type())
: _M_buf(__bytebuf), _M_cvt(__pcvt), _M_state(__state)
{
if (!_M_cvt)
__throw_logic_error("wbuffer_convert");
_M_always_noconv = _M_cvt->always_noconv();
if (_M_buf)
{
this->setp(_M_put_area, _M_put_area + _S_buffer_length);
this->setg(_M_get_area + _S_putback_length,
_M_get_area + _S_putback_length,
_M_get_area + _S_putback_length);
}
}
~wbuffer_convert() = default;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2176. Special members for wstring_convert and wbuffer_convert
wbuffer_convert(const wbuffer_convert&) = delete;
wbuffer_convert& operator=(const wbuffer_convert&) = delete;
streambuf* rdbuf() const noexcept { return _M_buf; }
streambuf*
rdbuf(streambuf *__bytebuf) noexcept
{
auto __prev = _M_buf;
_M_buf = __bytebuf;
return __prev;
}
/// The conversion state following the last conversion.
state_type state() const noexcept { return _M_state; }
protected:
int
sync()
{ return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }
typename _Wide_streambuf::int_type
overflow(typename _Wide_streambuf::int_type ___out)
{
if (!_M_buf || !_M_conv_put())
return _Tr::eof();
else if (!_Tr::eq_int_type(___out, _Tr::eof()))
return this->sputc(___out);
return _Tr::not_eof(___out);
}
typename _Wide_streambuf::int_type
underflow()
{
if (!_M_buf)
return _Tr::eof();
if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))
return _Tr::to_int_type(*this->gptr());
else
return _Tr::eof();
}
streamsize
xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n)
{
if (!_M_buf || __n == 0)
return 0;
streamsize __done = 0;
do
{
auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
__n - __done);
_Tr::copy(this->pptr(), __s + __done, __nn);
this->pbump(__nn);
__done += __nn;
} while (__done < __n && _M_conv_put());
return __done;
}
private:
// fill the get area from converted contents of the byte stream buffer
bool
_M_conv_get()
{
const streamsize __pb1 = this->gptr() - this->eback();
const streamsize __pb2 = _S_putback_length;
const streamsize __npb = std::min(__pb1, __pb2);
_Tr::move(_M_get_area + _S_putback_length - __npb,
this->gptr() - __npb, __npb);
streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;
__nbytes = std::min(__nbytes, _M_buf->in_avail());
if (__nbytes < 1)
__nbytes = 1;
__nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
if (__nbytes < 1)
return false;
__nbytes += _M_unconv;
// convert _M_get_buf into _M_get_area
_Elem* __outbuf = _M_get_area + _S_putback_length;
_Elem* __outnext = __outbuf;
const char* __bnext = _M_get_buf;
codecvt_base::result __result;
if (_M_always_noconv)
__result = codecvt_base::noconv;
else
{
_Elem* __outend = _M_get_area + _S_buffer_length;
__result = _M_cvt->in(_M_state,
__bnext, __bnext + __nbytes, __bnext,
__outbuf, __outend, __outnext);
}
if (__result == codecvt_base::noconv)
{
// cast is safe because noconv means _Elem is same type as char
auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);
_Tr::copy(__outbuf, __get_buf, __nbytes);
_M_unconv = 0;
return true;
}
if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);
this->setg(__outbuf, __outbuf, __outnext);
return __result != codecvt_base::error;
}
// unused
bool
_M_put(...)
{ return false; }
bool
_M_put(const char* __p, streamsize __n)
{
if (_M_buf->sputn(__p, __n) < __n)
return false;
return true;
}
// convert the put area and write to the byte stream buffer
bool
_M_conv_put()
{
_Elem* const __first = this->pbase();
const _Elem* const __last = this->pptr();
const streamsize __pending = __last - __first;
if (_M_always_noconv)
return _M_put(__first, __pending);
char __outbuf[2 * _S_buffer_length];
const _Elem* __next = __first;
const _Elem* __start;
do
{
__start = __next;
char* __outnext = __outbuf;
char* const __outlast = __outbuf + sizeof(__outbuf);
auto __result = _M_cvt->out(_M_state, __next, __last, __next,
__outnext, __outlast, __outnext);
if (__result == codecvt_base::error)
return false;
else if (__result == codecvt_base::noconv)
return _M_put(__next, __pending);
if (!_M_put(__outbuf, __outnext - __outbuf))
return false;
}
while (__next != __last && __next != __start);
if (__next != __last)
_Tr::move(__first, __next, __last - __next);
this->pbump(__first - __next);
return __next != __first;
}
streambuf* _M_buf;
unique_ptr<_Codecvt> _M_cvt;
state_type _M_state;
static const streamsize _S_buffer_length = 32;
static const streamsize _S_putback_length = 3;
_Elem _M_put_area[_S_buffer_length];
_Elem _M_get_area[_S_buffer_length];
streamsize _M_unconv = 0;
char _M_get_buf[_S_buffer_length-_S_putback_length];
bool _M_always_noconv;
};
#endif // _GLIBCXX_USE_WCHAR_T
/// @} group locales
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#endif // __cplusplus
#endif /* _LOCALE_CONV_H */
| [
"htminhnguyen@gmail.com"
] | htminhnguyen@gmail.com |
b15307509ba0f05e7575a3e8cb246f945307ddd6 | eac812b8fde25475f85eb427cc3b9883bd3e59a8 | /guilib/include/rtabmap/gui/GraphViewer.h | e6fa9a6eaba0dc51506990461433e8b14f5256d3 | [
"BSD-3-Clause"
] | permissive | Riotpiaole/rtabmap | f6dc452f07310ea4d682c3611f8e03267a94cde3 | 2b8b36db2ed7a08361dcffc9e2da3070b92a3883 | refs/heads/master | 2020-08-15T20:22:03.547609 | 2020-04-27T15:13:26 | 2020-04-27T15:13:26 | 215,402,703 | 0 | 0 | BSD-3-Clause | 2019-10-15T21:47:24 | 2019-10-15T21:47:24 | null | UTF-8 | C++ | false | false | 8,612 | h | /*
Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the Universite de Sherbrooke nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef RTABMAP_GRAPHVIEWER_H_
#define RTABMAP_GRAPHVIEWER_H_
#include "rtabmap/gui/RtabmapGuiExp.h" // DLL export/import defines
#include <QGraphicsView>
#include <QtCore/QMap>
#include <QtCore/QSettings>
#include <rtabmap/core/Link.h>
#include <rtabmap/core/GPS.h>
#include <opencv2/opencv.hpp>
#include <map>
#include <vector>
class QGraphicsItem;
class QGraphicsPixmapItem;
class QGraphicsItemGroup;
namespace rtabmap {
class NodeItem;
class LinkItem;
class RTABMAPGUI_EXP GraphViewer : public QGraphicsView {
Q_OBJECT;
public:
GraphViewer(QWidget * parent = 0);
virtual ~GraphViewer();
void setWorldMapRotation(const float & theta);
float getWorldMapRotation() const {return _worldMapRotation;}
void updateGraph(const std::map<int, Transform> & poses,
const std::multimap<int, Link> & constraints,
const std::map<int, int> & mapIds,
const std::map<int, int> & weights = std::map<int, int>());
void updateGTGraph(const std::map<int, Transform> & poses);
void updateGPSGraph(
const std::map<int, Transform> & gpsMapPoses,
const std::map<int, GPS> & gpsValues);
void updateReferentialPosition(const Transform & t);
void updateMap(const cv::Mat & map8U, float resolution, float xMin, float yMin);
void updatePosterior(const std::map<int, float> & posterior, float fixedMax = 0.0f, int zValueOffset = 0);
void updateLocalPath(const std::vector<int> & localPath);
void setGlobalPath(const std::vector<std::pair<int, Transform> > & globalPath);
void setCurrentGoalID(int id, const Transform & pose = Transform());
void setLocalRadius(float radius);
void clearGraph();
void clearMap();
void clearPosterior();
void clearAll();
void saveSettings(QSettings & settings, const QString & group = "") const;
void loadSettings(QSettings & settings, const QString & group = "");
//getters
const QString & getWorkingDirectory() const {return _workingDirectory;}
float getNodeRadius() const {return _nodeRadius;}
float getLinkWidth() const {return _linkWidth;}
const QColor & getNodeColor() const {return _nodeColor;}
const QColor & getCurrentGoalColor() const {return _currentGoalColor;}
const QColor & getNeighborColor() const {return _neighborColor;}
const QColor & getGlobalLoopClosureColor() const {return _loopClosureColor;}
const QColor & getLocalLoopClosureColor() const {return _loopClosureLocalColor;}
const QColor & getUserLoopClosureColor() const {return _loopClosureUserColor;}
const QColor & getVirtualLoopClosureColor() const {return _loopClosureVirtualColor;}
const QColor & getNeighborMergedColor() const {return _neighborMergedColor;}
const QColor & getRejectedLoopClosureColor() const {return _loopClosureRejectedColor;}
const QColor & getLocalPathColor() const {return _localPathColor;}
const QColor & getGlobalPathColor() const {return _globalPathColor;}
const QColor & getGTColor() const {return _gtPathColor;}
const QColor & getGPSColor() const {return _gpsPathColor;}
const QColor & getIntraSessionLoopColor() const {return _loopIntraSessionColor;}
const QColor & getInterSessionLoopColor() const {return _loopInterSessionColor;}
bool isIntraInterSessionColorsEnabled() const {return _intraInterSessionColors;}
bool isGridMapVisible() const;
bool isOriginVisible() const;
bool isReferentialVisible() const;
bool isLocalRadiusVisible() const;
float getLoopClosureOutlierThr() const {return _loopClosureOutlierThr;}
float getMaxLinkLength() const {return _maxLinkLength;}
bool isGraphVisible() const;
bool isGlobalPathVisible() const;
bool isLocalPathVisible() const;
bool isGtGraphVisible() const;
bool isGPSGraphVisible() const;
bool isOrientationENU() const;
// setters
void setWorkingDirectory(const QString & path);
void setNodeVisible(bool visible);
void setNodeRadius(float radius);
void setLinkWidth(float width);
void setNodeColor(const QColor & color);
void setCurrentGoalColor(const QColor & color);
void setNeighborColor(const QColor & color);
void setGlobalLoopClosureColor(const QColor & color);
void setLocalLoopClosureColor(const QColor & color);
void setUserLoopClosureColor(const QColor & color);
void setVirtualLoopClosureColor(const QColor & color);
void setNeighborMergedColor(const QColor & color);
void setLandmarkColor(const QColor & color);
void setRejectedLoopClosureColor(const QColor & color);
void setLocalPathColor(const QColor & color);
void setGlobalPathColor(const QColor & color);
void setGTColor(const QColor & color);
void setGPSColor(const QColor & color);
void setIntraSessionLoopColor(const QColor & color);
void setInterSessionLoopColor(const QColor & color);
void setIntraInterSessionColorsEnabled(bool enabled);
void setGridMapVisible(bool visible);
void setOriginVisible(bool visible);
void setReferentialVisible(bool visible);
void setLocalRadiusVisible(bool visible);
void setLoopClosureOutlierThr(float value);
void setMaxLinkLength(float value);
void setGraphVisible(bool visible);
void setGlobalPathVisible(bool visible);
void setLocalPathVisible(bool visible);
void setGtGraphVisible(bool visible);
void setGPSGraphVisible(bool visible);
void setOrientationENU(bool enabled);
Q_SIGNALS:
void configChanged();
void mapShownRequested();
public Q_SLOTS:
void restoreDefaults();
protected:
virtual void wheelEvent ( QWheelEvent * event );
virtual void contextMenuEvent(QContextMenuEvent * event);
private:
QString _workingDirectory;
QColor _nodeColor;
QColor _currentGoalColor;
QColor _neighborColor;
QColor _loopClosureColor;
QColor _loopClosureLocalColor;
QColor _loopClosureUserColor;
QColor _loopClosureVirtualColor;
QColor _neighborMergedColor;
QColor _landmarkColor;
QColor _loopClosureRejectedColor;
QColor _localPathColor;
QColor _globalPathColor;
QColor _gtPathColor;
QColor _gpsPathColor;
QColor _loopIntraSessionColor;
QColor _loopInterSessionColor;
bool _intraInterSessionColors;
float _worldMapRotation;
QGraphicsItem * _world;
QGraphicsItem * _root;
QGraphicsItem * _graphRoot;
QGraphicsItem * _globalPathRoot;
QGraphicsItem * _localPathRoot;
QGraphicsItem * _gtGraphRoot;
QGraphicsItem * _gpsGraphRoot;
QMap<int, NodeItem*> _nodeItems;
QMultiMap<int, LinkItem*> _linkItems;
QMap<int, NodeItem*> _gtNodeItems;
QMap<int, NodeItem*> _gpsNodeItems;
QMultiMap<int, LinkItem*> _gtLinkItems;
QMultiMap<int, LinkItem*> _gpsLinkItems;
QMultiMap<int, LinkItem*> _localPathLinkItems;
QMultiMap<int, LinkItem*> _globalPathLinkItems;
bool _nodeVisible;
float _nodeRadius;
float _linkWidth;
QGraphicsPixmapItem * _gridMap;
QGraphicsItemGroup * _referential;
QGraphicsItemGroup * _originReferential;
float _gridCellSize;
QGraphicsEllipseItem * _localRadius;
float _loopClosureOutlierThr;
float _maxLinkLength;
bool _orientationENU;
};
} /* namespace rtabmap */
#endif /* GRAPHVIEWER_H_ */
| [
"rlian072@uottawa.ca"
] | rlian072@uottawa.ca |
049594514fdfd9df6057261ec3c5b3fa1b576f1b | 727213382e3dbd831fa6168ae5dfeed26e22f153 | /tensorstore/util/garbage_collection/std_array.h | 34b32fe520f5a3d4f587abb5fcbc9ff5465d349b | [
"BSD-3-Clause",
"MIT",
"Apache-2.0",
"BSD-2-Clause",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | google/tensorstore | e3c41c9de41bdd56f26bbe31307c09d4ddd0278d | d38958e88130e7922f2c5d856a12114546ac9b73 | refs/heads/master | 2023-08-29T07:15:28.642462 | 2023-08-29T06:42:04 | 2023-08-29T06:43:13 | 251,312,202 | 1,190 | 88 | NOASSERTION | 2023-09-05T07:40:51 | 2020-03-30T13:24:59 | C++ | UTF-8 | C++ | false | false | 986 | h | // Copyright 2021 The TensorStore Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef TENSORSTORE_UTIL_GARBAGE_COLLECTION_STD_ARRAY_H_
#define TENSORSTORE_UTIL_GARBAGE_COLLECTION_STD_ARRAY_H_
/// \file
///
/// Defines garbage collection for C arrays and `std::array`, via
/// `ApplyMembers`.
#include "tensorstore/util/apply_members/std_array.h"
#include "tensorstore/util/garbage_collection/fwd.h"
#endif // TENSORSTORE_UTIL_GARBAGE_COLLECTION_STD_ARRAY_H_
| [
"copybara-worker@google.com"
] | copybara-worker@google.com |
9159421df981f83de7e244be165569d657505bdf | ac178f50d1e015d8ec5284c850810d724ad6c5dc | /Training/src/modules/DisplayManyImages.cpp | 0deb3df9b0bef953cc1f451449dd187ef8bbc082 | [] | no_license | greiny/NN_Saliency | 09861a038356394cf2b495345cdfa1527da40e14 | ef6fe1f78ffc387b6692d3e2b5ef774491b22b8d | refs/heads/master | 2020-04-12T11:09:08.229607 | 2018-12-19T23:54:21 | 2018-12-19T23:54:21 | 162,450,725 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,897 | cpp | #include "DisplayManyImages.h"
using namespace cv;
using namespace std;
/*Function///////////////////////////////////////////////////////////////
Name: ShowManyImages
Purpose:
This is a function illustrating how to display more than one
image in a single window using Intel OpenCV
Parameters:
string title: Title of the window to be displayed
int nArgs: Number of images to be displayed
Mat img1: First Mat, which contains the first image
...
Mat imgN: First Mat, which contains the Nth image
Language: C++
The method used is to set the ROIs of a Single Big image and then resizing
and copying the input images on to the Single Big Image.
This function does not stretch the image...
It resizes the image without modifying the width/height ratio..
This function can be called like this:
ShowManyImages("Images", 5, img2, img2, img3, img4, img5);
This function can display upto 12 images in a single window.
It does not check whether the arguments are of type Mat or not.
The maximum window size is 700 by 660 pixels.
Does not display anything if the number of arguments is less than
one or greater than 12.
Idea was from [[BettySanchi]] of OpenCV Yahoo! Groups.
If you have trouble compiling and/or executing
this code, I would like to hear about it.
You could try posting on the OpenCV Yahoo! Groups
[url]http://groups.yahoo.com/group/OpenCV/messages/ [/url]
Parameswaran,
Chennai, India.
cegparamesh[at]gmail[dot]com
...
///////////////////////////////////////////////////////////////////////*/
void ShowManyImages(string title, int nArgs, ...) {
int size;
int i;
int m, n;
int x, y;
// w - Maximum number of images in a row
// h - Maximum number of images in a column
int w, h;
// scale - How much we have to resize the image
float scale;
int max;
// If the number of arguments is lesser than 0 or greater than 12
// return without displaying
if(nArgs <= 0) {
printf("Number of arguments too small....\n");
return;
}
else if(nArgs > 14) {
printf("Number of arguments too large, can only handle maximally 12 images at a time ...\n");
return;
}
// Determine the size of the image,
// and the number of rows/cols
// from number of arguments
else if (nArgs == 1) {
w = h = 1;
size = 300;
}
else if (nArgs == 2) {
w = 2; h = 1;
size = 300;
}
else if (nArgs == 3 || nArgs == 4) {
w = 2; h = 2;
size = 300;
}
else if (nArgs == 5 || nArgs == 6) {
w = 3; h = 2;
size = 200;
}
else if (nArgs == 7 || nArgs == 8) {
w = 4; h = 2;
size = 200;
}
else {
w = 4; h = 3;
size = 150;
}
// Create a new 3 channel image
Mat DispImage = Mat::zeros(Size(100 + size*w, 60 + size*h), CV_8UC3);
// Used to get the arguments passed
va_list args;
va_start(args, nArgs);
// Loop for nArgs number of arguments
for (i = 0, m = 20, n = 20; i < nArgs; i++, m += (20 + size)) {
// Get the Pointer to the IplImage
Mat img = va_arg(args, Mat);
// Check whether it is NULL or not
// If it is NULL, release the image, and return
if(img.empty()) {
printf("Invalid arguments");
return;
}
// Find the width and height of the image
x = img.cols;
y = img.rows;
// Find whether height or width is greater in order to resize the image
max = (x > y)? x: y;
// Find the scaling factor to resize the image
scale = (float) ( (float) max / size );
// Used to Align the images
if( i % w == 0 && m!= 20) {
m = 20;
n+= 20 + size;
}
// Set the image ROI to display the current image
// Resize the input image and copy the it to the Single Big Image
Rect ROI(m, n, (int)( x/scale ), (int)( y/scale ));
Mat temp; resize(img,temp, Size(ROI.width, ROI.height));
temp.copyTo(DispImage(ROI));
}
// Create a new window, and show the Single Big Image
imshow( title, DispImage);
// End the number of arguments
va_end(args);
}
| [
"greiny@naver.com"
] | greiny@naver.com |
3376ed154e9eedc2ba9383a2456c01c65181aa73 | 43ae0d65a9acbfbfe8c36e158e1a590f6db02ad5 | /jni/skia/src/core/SkPicturePlayback.cpp | 80189ab974481a589287ae94a3fc4bd8bc571738 | [
"MIT"
] | permissive | identy/WiEngine | bfd0f5b95f0be72274e1dfb341d732d4a571993c | 2fb4276f558a5b1660d940b982c591cb7c73aec8 | refs/heads/master | 2020-12-25T01:27:01.452216 | 2013-04-22T03:22:24 | 2013-04-22T03:22:24 | 9,659,254 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 52,841 | cpp | #include "SkPicturePlayback.h"
#include "SkPictureRecord.h"
#include "SkTypeface.h"
#include <new>
/* Define this to spew out a debug statement whenever we skip the remainder of
a save/restore block because a clip... command returned false (empty).
*/
#define SPEW_CLIP_SKIPPINGx
SkPicturePlayback::SkPicturePlayback() {
this->init();
}
SkPicturePlayback::SkPicturePlayback(const SkPictureRecord& record) {
#ifdef SK_DEBUG_SIZE
size_t overallBytes, bitmapBytes, matricesBytes,
paintBytes, pathBytes, pictureBytes, regionBytes;
int bitmaps = record.bitmaps(&bitmapBytes);
int matrices = record.matrices(&matricesBytes);
int paints = record.paints(&paintBytes);
int paths = record.paths(&pathBytes);
int pictures = record.pictures(&pictureBytes);
int regions = record.regions(®ionBytes);
SkDebugf("picture record mem used %zd (stream %zd) ", record.size(),
record.streamlen());
if (bitmaps != 0)
SkDebugf("bitmaps size %zd (bitmaps:%d) ", bitmapBytes, bitmaps);
if (matrices != 0)
SkDebugf("matrices size %zd (matrices:%d) ", matricesBytes, matrices);
if (paints != 0)
SkDebugf("paints size %zd (paints:%d) ", paintBytes, paints);
if (paths != 0)
SkDebugf("paths size %zd (paths:%d) ", pathBytes, paths);
if (pictures != 0)
SkDebugf("pictures size %zd (pictures:%d) ", pictureBytes, pictures);
if (regions != 0)
SkDebugf("regions size %zd (regions:%d) ", regionBytes, regions);
if (record.fPointWrites != 0)
SkDebugf("points size %zd (points:%d) ", record.fPointBytes, record.fPointWrites);
if (record.fRectWrites != 0)
SkDebugf("rects size %zd (rects:%d) ", record.fRectBytes, record.fRectWrites);
if (record.fTextWrites != 0)
SkDebugf("text size %zd (text strings:%d) ", record.fTextBytes, record.fTextWrites);
SkDebugf("\n");
#endif
#ifdef SK_DEBUG_DUMP
record.dumpMatrices();
record.dumpPaints();
#endif
record.validate();
const SkWriter32& writer = record.writeStream();
init();
if (writer.size() == 0)
return;
{
size_t size = writer.size();
void* buffer = sk_malloc_throw(size);
writer.flatten(buffer);
fReader.setMemory(buffer, size); // fReader owns buffer now
}
// copy over the refcnt dictionary to our reader
//
fRCPlayback.reset(&record.fRCSet);
fRCPlayback.setupBuffer(fReader);
fTFPlayback.reset(&record.fTFSet);
fTFPlayback.setupBuffer(fReader);
const SkTDArray<const SkFlatBitmap* >& bitmaps = record.getBitmaps();
fBitmapCount = bitmaps.count();
if (fBitmapCount > 0) {
fBitmaps = SkNEW_ARRAY(SkBitmap, fBitmapCount);
for (const SkFlatBitmap** flatBitmapPtr = bitmaps.begin();
flatBitmapPtr != bitmaps.end(); flatBitmapPtr++) {
const SkFlatBitmap* flatBitmap = *flatBitmapPtr;
int index = flatBitmap->index() - 1;
flatBitmap->unflatten(&fBitmaps[index], &fRCPlayback);
}
}
const SkTDArray<const SkFlatMatrix* >& matrices = record.getMatrices();
fMatrixCount = matrices.count();
if (fMatrixCount > 0) {
fMatrices = SkNEW_ARRAY(SkMatrix, fMatrixCount);
for (const SkFlatMatrix** matrixPtr = matrices.begin();
matrixPtr != matrices.end(); matrixPtr++) {
const SkFlatMatrix* flatMatrix = *matrixPtr;
flatMatrix->unflatten(&fMatrices[flatMatrix->index() - 1]);
}
}
const SkTDArray<const SkFlatPaint* >& paints = record.getPaints();
fPaintCount = paints.count();
if (fPaintCount > 0) {
fPaints = SkNEW_ARRAY(SkPaint, fPaintCount);
for (const SkFlatPaint** flatPaintPtr = paints.begin();
flatPaintPtr != paints.end(); flatPaintPtr++) {
const SkFlatPaint* flatPaint = *flatPaintPtr;
int index = flatPaint->index() - 1;
SkASSERT((unsigned)index < (unsigned)fPaintCount);
flatPaint->unflatten(&fPaints[index], &fRCPlayback, &fTFPlayback);
}
}
fPathHeap = record.fPathHeap;
SkSafeRef(fPathHeap);
const SkTDArray<SkPicture* >& pictures = record.getPictureRefs();
fPictureCount = pictures.count();
if (fPictureCount > 0) {
fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount);
for (int i = 0; i < fPictureCount; i++) {
fPictureRefs[i] = pictures[i];
fPictureRefs[i]->ref();
}
}
const SkTDArray<SkShape* >& shapes = record.getShapes();
fShapeCount = shapes.count();
if (fShapeCount > 0) {
fShapes = SkNEW_ARRAY(SkShape*, fShapeCount);
for (int i = 0; i < fShapeCount; i++) {
SkShape* s = shapes[i];
SkSafeRef(s);
fShapes[i] = s;
}
}
const SkTDArray<const SkFlatRegion* >& regions = record.getRegions();
fRegionCount = regions.count();
if (fRegionCount > 0) {
fRegions = SkNEW_ARRAY(SkRegion, fRegionCount);
for (const SkFlatRegion** flatRegionPtr = regions.begin();
flatRegionPtr != regions.end(); flatRegionPtr++) {
const SkFlatRegion* flatRegion = *flatRegionPtr;
flatRegion->unflatten(&fRegions[flatRegion->index() - 1]);
}
}
#ifdef SK_DEBUG_SIZE
int overall = fPlayback->size(&overallBytes);
bitmaps = fPlayback->bitmaps(&bitmapBytes);
paints = fPlayback->paints(&paintBytes);
paths = fPlayback->paths(&pathBytes);
pictures = fPlayback->pictures(&pictureBytes);
regions = fPlayback->regions(®ionBytes);
SkDebugf("playback size %zd (objects:%d) ", overallBytes, overall);
if (bitmaps != 0)
SkDebugf("bitmaps size %zd (bitmaps:%d) ", bitmapBytes, bitmaps);
if (paints != 0)
SkDebugf("paints size %zd (paints:%d) ", paintBytes, paints);
if (paths != 0)
SkDebugf("paths size %zd (paths:%d) ", pathBytes, paths);
if (pictures != 0)
SkDebugf("pictures size %zd (pictures:%d) ", pictureBytes, pictures);
if (regions != 0)
SkDebugf("regions size %zd (regions:%d) ", regionBytes, regions);
SkDebugf("\n");
#endif
}
SkPicturePlayback::SkPicturePlayback(const SkPicturePlayback& src) {
this->init();
// copy the data from fReader
{
size_t size = src.fReader.size();
void* buffer = sk_malloc_throw(size);
memcpy(buffer, src.fReader.base(), size);
fReader.setMemory(buffer, size);
}
int i;
fBitmapCount = src.fBitmapCount;
fBitmaps = SkNEW_ARRAY(SkBitmap, fBitmapCount);
for (i = 0; i < fBitmapCount; i++) {
fBitmaps[i] = src.fBitmaps[i];
}
fMatrixCount = src.fMatrixCount;
fMatrices = SkNEW_ARRAY(SkMatrix, fMatrixCount);
memcpy(fMatrices, src.fMatrices, fMatrixCount * sizeof(SkMatrix));
fPaintCount = src.fPaintCount;
fPaints = SkNEW_ARRAY(SkPaint, fPaintCount);
for (i = 0; i < fPaintCount; i++) {
fPaints[i] = src.fPaints[i];
}
fPathHeap = src.fPathHeap;
SkSafeRef(fPathHeap);
fPictureCount = src.fPictureCount;
fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount);
for (int i = 0; i < fPictureCount; i++) {
fPictureRefs[i] = src.fPictureRefs[i];
fPictureRefs[i]->ref();
}
fShapeCount = src.fShapeCount;
fShapes = SkNEW_ARRAY(SkShape*, fShapeCount);
for (int i = 0; i < fShapeCount; i++) {
SkShape* s = src.fShapes[i];
SkSafeRef(s);
fShapes[i] = s;
}
fRegionCount = src.fRegionCount;
fRegions = SkNEW_ARRAY(SkRegion, fRegionCount);
for (i = 0; i < fRegionCount; i++) {
fRegions[i] = src.fRegions[i];
}
}
void SkPicturePlayback::init() {
fBitmaps = NULL;
fMatrices = NULL;
fPaints = NULL;
fPathHeap = NULL;
fPictureRefs = NULL;
fShapes = NULL;
fRegions = NULL;
fBitmapCount = fMatrixCount = fPaintCount = fPictureCount =
fRegionCount = fShapeCount = 0;
fFactoryPlayback = NULL;
}
SkPicturePlayback::~SkPicturePlayback() {
sk_free((void*) fReader.base());
SkDELETE_ARRAY(fBitmaps);
SkDELETE_ARRAY(fMatrices);
SkDELETE_ARRAY(fPaints);
SkDELETE_ARRAY(fRegions);
SkSafeUnref(fPathHeap);
for (int i = 0; i < fPictureCount; i++) {
fPictureRefs[i]->unref();
}
SkDELETE_ARRAY(fPictureRefs);
for (int i = 0; i < fShapeCount; i++) {
SkSafeUnref(fShapes[i]);
}
SkDELETE_ARRAY(fShapes);
SkDELETE(fFactoryPlayback);
}
void SkPicturePlayback::dumpSize() const {
SkDebugf("--- picture size: ops=%d bitmaps=%d [%d] matrices=%d [%d] paints=%d [%d] paths=%d regions=%d\n",
fReader.size(),
fBitmapCount, fBitmapCount * sizeof(SkBitmap),
fMatrixCount, fMatrixCount * sizeof(SkMatrix),
fPaintCount, fPaintCount * sizeof(SkPaint),
fPathHeap ? fPathHeap->count() : 0,
fRegionCount);
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// The chunks are writte/read in this order...
#define PICT_READER_TAG SkSetFourByteTag('r', 'e', 'a', 'd')
#define PICT_FACTORY_TAG SkSetFourByteTag('f', 'a', 'c', 't')
#define PICT_TYPEFACE_TAG SkSetFourByteTag('t', 'p', 'f', 'c')
#define PICT_PICTURE_TAG SkSetFourByteTag('p', 'c', 't', 'r')
#define PICT_ARRAYS_TAG SkSetFourByteTag('a', 'r', 'a', 'y')
// these are all inside the ARRAYS tag
#define PICT_BITMAP_TAG SkSetFourByteTag('b', 't', 'm', 'p')
#define PICT_MATRIX_TAG SkSetFourByteTag('m', 't', 'r', 'x')
#define PICT_PAINT_TAG SkSetFourByteTag('p', 'n', 't', ' ')
#define PICT_PATH_TAG SkSetFourByteTag('p', 't', 'h', ' ')
#define PICT_REGION_TAG SkSetFourByteTag('r', 'g', 'n', ' ')
#define PICT_SHAPE_TAG SkSetFourByteTag('s', 'h', 'p', ' ')
#include "SkStream.h"
static void writeTagSize(SkFlattenableWriteBuffer& buffer, uint32_t tag,
uint32_t size) {
buffer.write32(tag);
buffer.write32(size);
}
static void writeTagSize(SkWStream* stream, uint32_t tag,
uint32_t size) {
stream->write32(tag);
stream->write32(size);
}
static void writeFactories(SkWStream* stream, const SkFactorySet& rec) {
int count = rec.count();
writeTagSize(stream, PICT_FACTORY_TAG, count);
SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count);
SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get();
rec.copyToArray(array);
for (int i = 0; i < count; i++) {
const char* name = SkFlattenable::FactoryToName(array[i]);
// SkDebugf("---- write factories [%d] %p <%s>\n", i, array[i], name);
if (NULL == name || 0 == *name) {
stream->writePackedUInt(0);
} else {
uint32_t len = strlen(name);
stream->writePackedUInt(len);
stream->write(name, len);
}
}
}
static void writeTypefaces(SkWStream* stream, const SkRefCntSet& rec) {
int count = rec.count();
writeTagSize(stream, PICT_TYPEFACE_TAG, count);
SkAutoSTMalloc<16, SkTypeface*> storage(count);
SkTypeface** array = (SkTypeface**)storage.get();
rec.copyToArray((SkRefCnt**)array);
for (int i = 0; i < count; i++) {
array[i]->serialize(stream);
}
}
void SkPicturePlayback::serialize(SkWStream* stream) const {
writeTagSize(stream, PICT_READER_TAG, fReader.size());
stream->write(fReader.base(), fReader.size());
SkRefCntSet typefaceSet;
SkFactorySet factSet;
SkFlattenableWriteBuffer buffer(1024);
buffer.setFlags(SkFlattenableWriteBuffer::kCrossProcess_Flag);
buffer.setTypefaceRecorder(&typefaceSet);
buffer.setFactoryRecorder(&factSet);
int i;
writeTagSize(buffer, PICT_BITMAP_TAG, fBitmapCount);
for (i = 0; i < fBitmapCount; i++) {
fBitmaps[i].flatten(buffer);
}
writeTagSize(buffer, PICT_MATRIX_TAG, fMatrixCount);
buffer.writeMul4(fMatrices, fMatrixCount * sizeof(SkMatrix));
writeTagSize(buffer, PICT_PAINT_TAG, fPaintCount);
for (i = 0; i < fPaintCount; i++) {
fPaints[i].flatten(buffer);
}
{
int count = fPathHeap ? fPathHeap->count() : 0;
writeTagSize(buffer, PICT_PATH_TAG, count);
if (count > 0) {
fPathHeap->flatten(buffer);
}
}
writeTagSize(buffer, PICT_REGION_TAG, fRegionCount);
for (i = 0; i < fRegionCount; i++) {
uint32_t size = fRegions[i].flatten(NULL);
buffer.write32(size);
SkAutoSMalloc<512> storage(size);
fRegions[i].flatten(storage.get());
buffer.writePad(storage.get(), size);
}
writeTagSize(buffer, PICT_SHAPE_TAG, fShapeCount);
for (i = 0; i < fShapeCount; i++) {
buffer.writeFlattenable(fShapes[i]);
}
// now we can write to the stream again
writeFactories(stream, factSet);
writeTypefaces(stream, typefaceSet);
writeTagSize(stream, PICT_PICTURE_TAG, fPictureCount);
for (i = 0; i < fPictureCount; i++) {
fPictureRefs[i]->serialize(stream);
}
writeTagSize(stream, PICT_ARRAYS_TAG, buffer.size());
buffer.writeToStream(stream);
}
///////////////////////////////////////////////////////////////////////////////
static int readTagSize(SkFlattenableReadBuffer& buffer, uint32_t expectedTag) {
uint32_t tag = buffer.readU32();
if (tag != expectedTag) {
sk_throw();
}
return buffer.readU32();
}
static int readTagSize(SkStream* stream, uint32_t expectedTag) {
uint32_t tag = stream->readU32();
if (tag != expectedTag) {
sk_throw();
}
return stream->readU32();
}
SkPicturePlayback::SkPicturePlayback(SkStream* stream) {
this->init();
int i;
{
size_t size = readTagSize(stream, PICT_READER_TAG);
void* storage = sk_malloc_throw(size);
stream->read(storage, size);
fReader.setMemory(storage, size);
}
int factoryCount = readTagSize(stream, PICT_FACTORY_TAG);
fFactoryPlayback = SkNEW_ARGS(SkFactoryPlayback, (factoryCount));
for (i = 0; i < factoryCount; i++) {
SkString str;
int len = stream->readPackedUInt();
str.resize(len);
stream->read(str.writable_str(), len);
// SkDebugf("--- factory playback [%d] <%s>\n", i, str.c_str());
fFactoryPlayback->base()[i] = SkFlattenable::NameToFactory(str.c_str());
}
int typefaceCount = readTagSize(stream, PICT_TYPEFACE_TAG);
fTFPlayback.setCount(typefaceCount);
for (i = 0; i < typefaceCount; i++) {
SkSafeUnref(fTFPlayback.set(i, SkTypeface::Deserialize(stream)));
}
fPictureCount = readTagSize(stream, PICT_PICTURE_TAG);
fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount);
for (i = 0; i < fPictureCount; i++) {
fPictureRefs[i] = SkNEW_ARGS(SkPicture, (stream));
}
/*
Now read the arrays chunk, and parse using a read buffer
*/
uint32_t size = readTagSize(stream, PICT_ARRAYS_TAG);
SkAutoMalloc storage(size);
stream->read(storage.get(), size);
SkFlattenableReadBuffer buffer(storage.get(), size);
fFactoryPlayback->setupBuffer(buffer);
fTFPlayback.setupBuffer(buffer);
fBitmapCount = readTagSize(buffer, PICT_BITMAP_TAG);
fBitmaps = SkNEW_ARRAY(SkBitmap, fBitmapCount);
for (i = 0; i < fBitmapCount; i++) {
fBitmaps[i].unflatten(buffer);
}
fMatrixCount = readTagSize(buffer, PICT_MATRIX_TAG);
fMatrices = SkNEW_ARRAY(SkMatrix, fMatrixCount);
buffer.read(fMatrices, fMatrixCount * sizeof(SkMatrix));
fPaintCount = readTagSize(buffer, PICT_PAINT_TAG);
fPaints = SkNEW_ARRAY(SkPaint, fPaintCount);
for (i = 0; i < fPaintCount; i++) {
fPaints[i].unflatten(buffer);
}
{
int count = readTagSize(buffer, PICT_PATH_TAG);
if (count > 0) {
fPathHeap = SkNEW_ARGS(SkPathHeap, (buffer));
}
}
fRegionCount = readTagSize(buffer, PICT_REGION_TAG);
fRegions = SkNEW_ARRAY(SkRegion, fRegionCount);
for (i = 0; i < fRegionCount; i++) {
uint32_t size = buffer.readU32();
SkDEBUGCODE(uint32_t bytes =) fRegions[i].unflatten(buffer.skip(size));
SkASSERT(size == bytes);
}
fShapeCount = readTagSize(buffer, PICT_SHAPE_TAG);
fShapes = SkNEW_ARRAY(SkShape*, fShapeCount);
for (i = 0; i < fShapeCount; i++) {
fShapes[i] = reinterpret_cast<SkShape*>(buffer.readFlattenable());
}
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifdef SPEW_CLIP_SKIPPING
struct SkipClipRec {
int fCount;
size_t fSize;
SkipClipRec() {
fCount = 0;
fSize = 0;
}
void recordSkip(size_t bytes) {
fCount += 1;
fSize += bytes;
}
};
#endif
void SkPicturePlayback::draw(SkCanvas& canvas) {
#ifdef ENABLE_TIME_DRAW
SkAutoTime at("SkPicture::draw", 50);
#endif
#ifdef SPEW_CLIP_SKIPPING
SkipClipRec skipRect, skipRegion, skipPath;
#endif
#ifdef ANDROID
SkAutoMutexAcquire autoMutex(fDrawMutex);
#endif
TextContainer text;
fReader.rewind();
while (!fReader.eof()) {
switch (fReader.readInt()) {
case CLIP_PATH: {
const SkPath& path = getPath();
SkRegion::Op op = (SkRegion::Op) getInt();
size_t offsetToRestore = getInt();
// HACK (false) until I can handle op==kReplace
if (!canvas.clipPath(path, op)) {
#ifdef SPEW_CLIP_SKIPPING
skipPath.recordSkip(offsetToRestore - fReader.offset());
#endif
fReader.setOffset(offsetToRestore);
}
} break;
case CLIP_REGION: {
const SkRegion& region = getRegion();
SkRegion::Op op = (SkRegion::Op) getInt();
size_t offsetToRestore = getInt();
if (!canvas.clipRegion(region, op)) {
#ifdef SPEW_CLIP_SKIPPING
skipRegion.recordSkip(offsetToRestore - fReader.offset());
#endif
fReader.setOffset(offsetToRestore);
}
} break;
case CLIP_RECT: {
const SkRect* rect = fReader.skipRect();
SkRegion::Op op = (SkRegion::Op) getInt();
size_t offsetToRestore = getInt();
if (!canvas.clipRect(*rect, op)) {
#ifdef SPEW_CLIP_SKIPPING
skipRect.recordSkip(offsetToRestore - fReader.offset());
#endif
fReader.setOffset(offsetToRestore);
}
} break;
case CONCAT:
canvas.concat(*getMatrix());
break;
case DRAW_BITMAP: {
const SkPaint* paint = getPaint();
const SkBitmap& bitmap = getBitmap();
const SkPoint* loc = fReader.skipPoint();
canvas.drawBitmap(bitmap, loc->fX, loc->fY, paint);
} break;
case DRAW_BITMAP_RECT: {
const SkPaint* paint = getPaint();
const SkBitmap& bitmap = getBitmap();
const SkIRect* src = this->getIRectPtr(); // may be null
const SkRect* dst = fReader.skipRect(); // required
canvas.drawBitmapRect(bitmap, src, *dst, paint);
} break;
case DRAW_BITMAP_MATRIX: {
const SkPaint* paint = getPaint();
const SkBitmap& bitmap = getBitmap();
const SkMatrix* matrix = getMatrix();
canvas.drawBitmapMatrix(bitmap, *matrix, paint);
} break;
case DRAW_CLEAR:
canvas.clear(getInt());
break;
case DRAW_DATA: {
size_t length = getInt();
canvas.drawData(fReader.skip(length), length);
// skip handles padding the read out to a multiple of 4
} break;
case DRAW_PAINT:
canvas.drawPaint(*getPaint());
break;
case DRAW_PATH: {
const SkPaint& paint = *getPaint();
canvas.drawPath(getPath(), paint);
} break;
case DRAW_PICTURE:
canvas.drawPicture(getPicture());
break;
case DRAW_POINTS: {
const SkPaint& paint = *getPaint();
SkCanvas::PointMode mode = (SkCanvas::PointMode)getInt();
size_t count = getInt();
const SkPoint* pts = (const SkPoint*)fReader.skip(sizeof(SkPoint) * count);
canvas.drawPoints(mode, count, pts, paint);
} break;
case DRAW_POS_TEXT: {
const SkPaint& paint = *getPaint();
getText(&text);
size_t points = getInt();
const SkPoint* pos = (const SkPoint*)fReader.skip(points * sizeof(SkPoint));
canvas.drawPosText(text.text(), text.length(), pos, paint);
} break;
case DRAW_POS_TEXT_H: {
const SkPaint& paint = *getPaint();
getText(&text);
size_t xCount = getInt();
const SkScalar constY = getScalar();
const SkScalar* xpos = (const SkScalar*)fReader.skip(xCount * sizeof(SkScalar));
canvas.drawPosTextH(text.text(), text.length(), xpos, constY,
paint);
} break;
case DRAW_POS_TEXT_H_TOP_BOTTOM: {
const SkPaint& paint = *getPaint();
getText(&text);
size_t xCount = getInt();
const SkScalar* xpos = (const SkScalar*)fReader.skip((3 + xCount) * sizeof(SkScalar));
const SkScalar top = *xpos++;
const SkScalar bottom = *xpos++;
const SkScalar constY = *xpos++;
if (!canvas.quickRejectY(top, bottom, SkCanvas::kAA_EdgeType)) {
canvas.drawPosTextH(text.text(), text.length(), xpos,
constY, paint);
}
} break;
case DRAW_RECT: {
const SkPaint& paint = *getPaint();
canvas.drawRect(*fReader.skipRect(), paint);
} break;
case DRAW_SHAPE: {
SkShape* shape = getShape();
if (shape) {
canvas.drawShape(shape);
}
} break;
case DRAW_SPRITE: {
const SkPaint* paint = getPaint();
const SkBitmap& bitmap = getBitmap();
int left = getInt();
int top = getInt();
canvas.drawSprite(bitmap, left, top, paint);
} break;
case DRAW_TEXT: {
const SkPaint& paint = *getPaint();
getText(&text);
SkScalar x = getScalar();
SkScalar y = getScalar();
canvas.drawText(text.text(), text.length(), x, y, paint);
} break;
case DRAW_TEXT_TOP_BOTTOM: {
const SkPaint& paint = *getPaint();
getText(&text);
const SkScalar* ptr = (const SkScalar*)fReader.skip(4 * sizeof(SkScalar));
// ptr[0] == x
// ptr[1] == y
// ptr[2] == top
// ptr[3] == bottom
if (!canvas.quickRejectY(ptr[2], ptr[3],
SkCanvas::kAA_EdgeType)) {
canvas.drawText(text.text(), text.length(), ptr[0], ptr[1],
paint);
}
} break;
case DRAW_TEXT_ON_PATH: {
const SkPaint& paint = *getPaint();
getText(&text);
const SkPath& path = getPath();
const SkMatrix* matrix = getMatrix();
canvas.drawTextOnPath(text.text(), text.length(), path,
matrix, paint);
} break;
case DRAW_VERTICES: {
const SkPaint& paint = *getPaint();
DrawVertexFlags flags = (DrawVertexFlags)getInt();
SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)getInt();
int vCount = getInt();
const SkPoint* verts = (const SkPoint*)fReader.skip(
vCount * sizeof(SkPoint));
const SkPoint* texs = NULL;
const SkColor* colors = NULL;
const uint16_t* indices = NULL;
int iCount = 0;
if (flags & DRAW_VERTICES_HAS_TEXS) {
texs = (const SkPoint*)fReader.skip(
vCount * sizeof(SkPoint));
}
if (flags & DRAW_VERTICES_HAS_COLORS) {
colors = (const SkColor*)fReader.skip(
vCount * sizeof(SkColor));
}
if (flags & DRAW_VERTICES_HAS_INDICES) {
iCount = getInt();
indices = (const uint16_t*)fReader.skip(
iCount * sizeof(uint16_t));
}
canvas.drawVertices(vmode, vCount, verts, texs, colors, NULL,
indices, iCount, paint);
} break;
case RESTORE:
canvas.restore();
break;
case ROTATE:
canvas.rotate(getScalar());
break;
case SAVE:
canvas.save((SkCanvas::SaveFlags) getInt());
break;
case SAVE_LAYER: {
const SkRect* boundsPtr = getRectPtr();
const SkPaint* paint = getPaint();
canvas.saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) getInt());
} break;
case SCALE: {
SkScalar sx = getScalar();
SkScalar sy = getScalar();
canvas.scale(sx, sy);
} break;
case SET_MATRIX:
canvas.setMatrix(*getMatrix());
break;
case SKEW: {
SkScalar sx = getScalar();
SkScalar sy = getScalar();
canvas.skew(sx, sy);
} break;
case TRANSLATE: {
SkScalar dx = getScalar();
SkScalar dy = getScalar();
canvas.translate(dx, dy);
} break;
default:
SkASSERT(0);
}
}
#ifdef SPEW_CLIP_SKIPPING
{
size_t size = skipRect.fSize + skipPath.fSize + skipRegion.fSize;
SkDebugf("--- Clip skips %d%% rect:%d path:%d rgn:%d\n",
size * 100 / fReader.offset(), skipRect.fCount, skipPath.fCount,
skipRegion.fCount);
}
#endif
// this->dumpSize();
}
void SkPicturePlayback::abort() {
fReader.skip(fReader.size() - fReader.offset());
}
///////////////////////////////////////////////////////////////////////////////
#if 0
uint32_t SkPicturePlayback::flatten(void* storage) const {
SkWBuffer buffer(storage);
buffer.write32(fBitmapCount);
int index;
for (index = 0; index < fBitmapCount; index++) {
const SkBitmap& bitmap = fBitmaps[index];
uint32_t size = bitmap.flatten(NULL, true);
buffer.write32(size);
void* local = buffer.skip(size);
bitmap.flatten(local, true);
}
buffer.write32(fPaintCount);
for (index = 0; index < fPaintCount; index++) {
SkFlattenableWriteBuffer flatWrite;
const SkPaint& paint = fPaints[index];
SkFlatPaint::Write(&flatWrite, paint);
uint32_t size = flatWrite.pos();
buffer.write32(size);
void* local = buffer.skip(size);
flatWrite.reset(local);
SkFlatPaint::Write(&flatWrite, paint);
}
buffer.write32(fPathCount);
for (index = 0; index < fPathCount; index++) {
const SkPath& path = fPaths[index];
uint32_t size = path.flatten(NULL);
buffer.write32(size);
void* local = buffer.skip(size);
path.flatten(local);
}
#if 0
buffer.write32(fPictureCount);
for (index = 0; index < fPictureCount; index++) {
const SkPicture& picture = fPictures[index];
uint32_t size = picture.flatten(NULL);
buffer.write32(size);
void* local = buffer.skip(size);
picture.flatten(local);
}
#endif
buffer.write32(fRegionCount);
for (index = 0; index < fRegionCount; index++) {
const SkRegion& region = fRegions[index];
size_t size = region.computeBufferSize();
buffer.write32(size);
void* local = buffer.skip(size);
region.writeToBuffer(local);
}
fReader.rewind();
size_t length = fReader.size();
buffer.write32(length);
memcpy(buffer.skip(length), fReader.base(), length);
return (uint32_t) buffer.pos();
}
void SkPicturePlayback::unflatten(const void* storage) {
SkRBuffer buffer(storage);
int index;
fBitmapCount = buffer.readU32();
fBitmaps = new SkBitmap[fBitmapCount];
for (index = 0; index < fBitmapCount; index++) {
uint32_t size = buffer.readU32();
const void* local = buffer.skip(size);
fBitmaps[index].unflatten(local);
}
fPaintCount = buffer.readU32();
fPaints = new SkPaint[fPaintCount];
for (index = 0; index < fPaintCount; index++) {
uint32_t size = buffer.readU32();
const void* local = buffer.skip(size);
SkFlatPaint::Read(local, &fPaints[index]);
}
fPathCount = buffer.readU32();
fPaths = new SkPath[fPathCount];
for (index = 0; index < fPathCount; index++) {
uint32_t size = buffer.readU32();
const void* local = buffer.skip(size);
fPaths[index].unflatten(local);
}
#if 0
fPictureCount = buffer.readU32();
fPictures = new SkPicture[fPictureCount];
for (index = 0; index < fPictureCount; index++) {
uint32_t size = buffer.readU32();
const void* local = buffer.skip(size);
fPictures[index].unflatten(local);
}
#endif
fRegionCount = buffer.readU32();
fRegions = new SkRegion[fRegionCount];
for (index = 0; index < fRegionCount; index++) {
uint32_t size = buffer.readU32();
const void* local = buffer.skip(size);
fRegions[index].readFromBuffer(local);
}
int32_t length = buffer.readS32();
const void* stream = buffer.skip(length);
fReader.setMemory(stream, length);
}
#endif
///////////////////////////////////////////////////////////////////////////////
#ifdef SK_DEBUG_SIZE
int SkPicturePlayback::size(size_t* sizePtr) {
int objects = bitmaps(sizePtr);
objects += paints(sizePtr);
objects += paths(sizePtr);
objects += pictures(sizePtr);
objects += regions(sizePtr);
*sizePtr = fReader.size();
return objects;
}
int SkPicturePlayback::bitmaps(size_t* size) {
size_t result = 0;
for (int index = 0; index < fBitmapCount; index++) {
// const SkBitmap& bitmap = fBitmaps[index];
result += sizeof(SkBitmap); // bitmap->size();
}
*size = result;
return fBitmapCount;
}
int SkPicturePlayback::paints(size_t* size) {
size_t result = 0;
for (int index = 0; index < fPaintCount; index++) {
// const SkPaint& paint = fPaints[index];
result += sizeof(SkPaint); // paint->size();
}
*size = result;
return fPaintCount;
}
int SkPicturePlayback::paths(size_t* size) {
size_t result = 0;
for (int index = 0; index < fPathCount; index++) {
const SkPath& path = fPaths[index];
result += path.flatten(NULL);
}
*size = result;
return fPathCount;
}
int SkPicturePlayback::regions(size_t* size) {
size_t result = 0;
for (int index = 0; index < fRegionCount; index++) {
// const SkRegion& region = fRegions[index];
result += sizeof(SkRegion); // region->size();
}
*size = result;
return fRegionCount;
}
#endif
#ifdef SK_DEBUG_DUMP
void SkPicturePlayback::dumpBitmap(const SkBitmap& bitmap) const {
char pBuffer[DUMP_BUFFER_SIZE];
char* bufferPtr = pBuffer;
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"BitmapData bitmap%p = {", &bitmap);
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kWidth, %d}, ", bitmap.width());
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kHeight, %d}, ", bitmap.height());
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kRowBytes, %d}, ", bitmap.rowBytes());
// start here;
SkDebugf("%s{0}};\n", pBuffer);
}
void dumpMatrix(const SkMatrix& matrix) const {
SkMatrix defaultMatrix;
defaultMatrix.reset();
char pBuffer[DUMP_BUFFER_SIZE];
char* bufferPtr = pBuffer;
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"MatrixData matrix%p = {", &matrix);
SkScalar scaleX = matrix.getScaleX();
if (scaleX != defaultMatrix.getScaleX())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kScaleX, %g}, ", SkScalarToFloat(scaleX));
SkScalar scaleY = matrix.getScaleY();
if (scaleY != defaultMatrix.getScaleY())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kScaleY, %g}, ", SkScalarToFloat(scaleY));
SkScalar skewX = matrix.getSkewX();
if (skewX != defaultMatrix.getSkewX())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kSkewX, %g}, ", SkScalarToFloat(skewX));
SkScalar skewY = matrix.getSkewY();
if (skewY != defaultMatrix.getSkewY())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kSkewY, %g}, ", SkScalarToFloat(skewY));
SkScalar translateX = matrix.getTranslateX();
if (translateX != defaultMatrix.getTranslateX())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kTranslateX, %g}, ", SkScalarToFloat(translateX));
SkScalar translateY = matrix.getTranslateY();
if (translateY != defaultMatrix.getTranslateY())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kTranslateY, %g}, ", SkScalarToFloat(translateY));
SkScalar perspX = matrix.getPerspX();
if (perspX != defaultMatrix.getPerspX())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kPerspX, %g}, ", SkFractToFloat(perspX));
SkScalar perspY = matrix.getPerspY();
if (perspY != defaultMatrix.getPerspY())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kPerspY, %g}, ", SkFractToFloat(perspY));
SkDebugf("%s{0}};\n", pBuffer);
}
void dumpPaint(const SkPaint& paint) const {
SkPaint defaultPaint;
char pBuffer[DUMP_BUFFER_SIZE];
char* bufferPtr = pBuffer;
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"PaintPointers paintPtrs%p = {", &paint);
const SkTypeface* typeface = paint.getTypeface();
if (typeface != defaultPaint.getTypeface())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kTypeface, %p}, ", typeface);
const SkPathEffect* pathEffect = paint.getPathEffect();
if (pathEffect != defaultPaint.getPathEffect())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kPathEffect, %p}, ", pathEffect);
const SkShader* shader = paint.getShader();
if (shader != defaultPaint.getShader())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kShader, %p}, ", shader);
const SkXfermode* xfermode = paint.getXfermode();
if (xfermode != defaultPaint.getXfermode())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kXfermode, %p}, ", xfermode);
const SkMaskFilter* maskFilter = paint.getMaskFilter();
if (maskFilter != defaultPaint.getMaskFilter())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kMaskFilter, %p}, ", maskFilter);
const SkColorFilter* colorFilter = paint.getColorFilter();
if (colorFilter != defaultPaint.getColorFilter())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kColorFilter, %p}, ", colorFilter);
const SkRasterizer* rasterizer = paint.getRasterizer();
if (rasterizer != defaultPaint.getRasterizer())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kRasterizer, %p}, ", rasterizer);
const SkDrawLooper* drawLooper = paint.getLooper();
if (drawLooper != defaultPaint.getLooper())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kDrawLooper, %p}, ", drawLooper);
SkDebugf("%s{0}};\n", pBuffer);
bufferPtr = pBuffer;
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"PaintScalars paintScalars%p = {", &paint);
SkScalar textSize = paint.getTextSize();
if (textSize != defaultPaint.getTextSize())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kTextSize, %g}, ", SkScalarToFloat(textSize));
SkScalar textScaleX = paint.getTextScaleX();
if (textScaleX != defaultPaint.getTextScaleX())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kTextScaleX, %g}, ", SkScalarToFloat(textScaleX));
SkScalar textSkewX = paint.getTextSkewX();
if (textSkewX != defaultPaint.getTextSkewX())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kTextSkewX, %g}, ", SkScalarToFloat(textSkewX));
SkScalar strokeWidth = paint.getStrokeWidth();
if (strokeWidth != defaultPaint.getStrokeWidth())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kStrokeWidth, %g}, ", SkScalarToFloat(strokeWidth));
SkScalar strokeMiter = paint.getStrokeMiter();
if (strokeMiter != defaultPaint.getStrokeMiter())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kStrokeMiter, %g}, ", SkScalarToFloat(strokeMiter));
SkDebugf("%s{0}};\n", pBuffer);
bufferPtr = pBuffer;
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"PaintInts = paintInts%p = {", &paint);
unsigned color = paint.getColor();
if (color != defaultPaint.getColor())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kColor, 0x%x}, ", color);
unsigned flags = paint.getFlags();
if (flags != defaultPaint.getFlags())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kFlags, 0x%x}, ", flags);
int align = paint.getTextAlign();
if (align != defaultPaint.getTextAlign())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kAlign, 0x%x}, ", align);
int strokeCap = paint.getStrokeCap();
if (strokeCap != defaultPaint.getStrokeCap())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kStrokeCap, 0x%x}, ", strokeCap);
int strokeJoin = paint.getStrokeJoin();
if (strokeJoin != defaultPaint.getStrokeJoin())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kAlign, 0x%x}, ", strokeJoin);
int style = paint.getStyle();
if (style != defaultPaint.getStyle())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kStyle, 0x%x}, ", style);
int textEncoding = paint.getTextEncoding();
if (textEncoding != defaultPaint.getTextEncoding())
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"{kTextEncoding, 0x%x}, ", textEncoding);
SkDebugf("%s{0}};\n", pBuffer);
SkDebugf("PaintData paint%p = {paintPtrs%p, paintScalars%p, paintInts%p};\n",
&paint, &paint, &paint, &paint);
}
void SkPicturePlayback::dumpPath(const SkPath& path) const {
SkDebugf("path dump unimplemented\n");
}
void SkPicturePlayback::dumpPicture(const SkPicture& picture) const {
SkDebugf("picture dump unimplemented\n");
}
void SkPicturePlayback::dumpRegion(const SkRegion& region) const {
SkDebugf("region dump unimplemented\n");
}
int SkPicturePlayback::dumpDrawType(char* bufferPtr, char* buffer, DrawType drawType) {
return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"k%s, ", DrawTypeToString(drawType));
}
int SkPicturePlayback::dumpInt(char* bufferPtr, char* buffer, char* name) {
return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"%s:%d, ", name, getInt());
}
int SkPicturePlayback::dumpRect(char* bufferPtr, char* buffer, char* name) {
const SkRect* rect = fReader.skipRect();
return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"%s:{l:%g t:%g r:%g b:%g}, ", name, SkScalarToFloat(rect.fLeft),
SkScalarToFloat(rect.fTop),
SkScalarToFloat(rect.fRight), SkScalarToFloat(rect.fBottom));
}
int SkPicturePlayback::dumpPoint(char* bufferPtr, char* buffer, char* name) {
SkPoint pt;
getPoint(&pt);
return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"%s:{x:%g y:%g}, ", name, SkScalarToFloat(pt.fX),
SkScalarToFloat(pt.fY));
}
void SkPicturePlayback::dumpPointArray(char** bufferPtrPtr, char* buffer, int count) {
char* bufferPtr = *bufferPtrPtr;
const SkPoint* pts = (const SkPoint*)fReadStream.getAtPos();
fReadStream.skip(sizeof(SkPoint) * count);
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"count:%d {", count);
for (int index = 0; index < count; index++)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"{x:%g y:%g}, ", SkScalarToFloat(pts[index].fX),
SkScalarToFloat(pts[index].fY));
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"} ");
*bufferPtrPtr = bufferPtr;
}
int SkPicturePlayback::dumpPtr(char* bufferPtr, char* buffer, char* name, void* ptr) {
return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"%s:%p, ", name, ptr);
}
int SkPicturePlayback::dumpRectPtr(char* bufferPtr, char* buffer, char* name) {
char result;
fReadStream.read(&result, sizeof(result));
if (result)
return dumpRect(bufferPtr, buffer, name);
else
return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"%s:NULL, ", name);
}
int SkPicturePlayback::dumpScalar(char* bufferPtr, char* buffer, char* name) {
return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"%s:%d, ", name, getScalar());
}
void SkPicturePlayback::dumpText(char** bufferPtrPtr, char* buffer) {
char* bufferPtr = *bufferPtrPtr;
int length = getInt();
bufferPtr += dumpDrawType(bufferPtr, buffer);
fReadStream.skipToAlign4();
char* text = (char*) fReadStream.getAtPos();
fReadStream.skip(length);
bufferPtr += dumpInt(bufferPtr, buffer, "length");
int limit = DUMP_BUFFER_SIZE - (bufferPtr - buffer) - 2;
length >>= 1;
if (limit > length)
limit = length;
if (limit > 0) {
*bufferPtr++ = '"';
for (int index = 0; index < limit; index++) {
*bufferPtr++ = *(unsigned short*) text;
text += sizeof(unsigned short);
}
*bufferPtr++ = '"';
}
*bufferPtrPtr = bufferPtr;
}
#define DUMP_DRAWTYPE(drawType) \
bufferPtr += dumpDrawType(bufferPtr, buffer, drawType)
#define DUMP_INT(name) \
bufferPtr += dumpInt(bufferPtr, buffer, #name)
#define DUMP_RECT_PTR(name) \
bufferPtr += dumpRectPtr(bufferPtr, buffer, #name)
#define DUMP_POINT(name) \
bufferPtr += dumpRect(bufferPtr, buffer, #name)
#define DUMP_RECT(name) \
bufferPtr += dumpRect(bufferPtr, buffer, #name)
#define DUMP_POINT_ARRAY(count) \
dumpPointArray(&bufferPtr, buffer, count)
#define DUMP_PTR(name, ptr) \
bufferPtr += dumpPtr(bufferPtr, buffer, #name, (void*) ptr)
#define DUMP_SCALAR(name) \
bufferPtr += dumpScalar(bufferPtr, buffer, #name)
#define DUMP_TEXT() \
dumpText(&bufferPtr, buffer)
void SkPicturePlayback::dumpStream() {
SkDebugf("RecordStream stream = {\n");
DrawType drawType;
TextContainer text;
fReadStream.rewind();
char buffer[DUMP_BUFFER_SIZE], * bufferPtr;
while (fReadStream.read(&drawType, sizeof(drawType))) {
bufferPtr = buffer;
DUMP_DRAWTYPE(drawType);
switch (drawType) {
case CLIP_PATH: {
DUMP_PTR(SkPath, &getPath());
DUMP_INT(SkRegion::Op);
DUMP_INT(offsetToRestore);
} break;
case CLIP_REGION: {
DUMP_PTR(SkRegion, &getRegion());
DUMP_INT(SkRegion::Op);
DUMP_INT(offsetToRestore);
} break;
case CLIP_RECT: {
DUMP_RECT(rect);
DUMP_INT(SkRegion::Op);
DUMP_INT(offsetToRestore);
} break;
case CONCAT:
DUMP_PTR(SkMatrix, getMatrix());
break;
case DRAW_BITMAP: {
DUMP_PTR(SkPaint, getPaint());
DUMP_PTR(SkBitmap, &getBitmap());
DUMP_SCALAR(left);
DUMP_SCALAR(top);
} break;
case DRAW_PAINT:
DUMP_PTR(SkPaint, getPaint());
break;
case DRAW_PATH: {
DUMP_PTR(SkPaint, getPaint());
DUMP_PTR(SkPath, &getPath());
} break;
case DRAW_PICTURE: {
DUMP_PTR(SkPicture, &getPicture());
} break;
case DRAW_POINTS: {
DUMP_PTR(SkPaint, getPaint());
(void)getInt(); // PointMode
size_t count = getInt();
fReadStream.skipToAlign4();
DUMP_POINT_ARRAY(count);
} break;
case DRAW_POS_TEXT: {
DUMP_PTR(SkPaint, getPaint());
DUMP_TEXT();
size_t points = getInt();
fReadStream.skipToAlign4();
DUMP_POINT_ARRAY(points);
} break;
case DRAW_POS_TEXT_H: {
DUMP_PTR(SkPaint, getPaint());
DUMP_TEXT();
size_t points = getInt();
fReadStream.skipToAlign4();
DUMP_SCALAR(top);
DUMP_SCALAR(bottom);
DUMP_SCALAR(constY);
DUMP_POINT_ARRAY(points);
} break;
case DRAW_RECT: {
DUMP_PTR(SkPaint, getPaint());
DUMP_RECT(rect);
} break;
case DRAW_SPRITE: {
DUMP_PTR(SkPaint, getPaint());
DUMP_PTR(SkBitmap, &getBitmap());
DUMP_SCALAR(left);
DUMP_SCALAR(top);
} break;
case DRAW_TEXT: {
DUMP_PTR(SkPaint, getPaint());
DUMP_TEXT();
DUMP_SCALAR(x);
DUMP_SCALAR(y);
} break;
case DRAW_TEXT_ON_PATH: {
DUMP_PTR(SkPaint, getPaint());
DUMP_TEXT();
DUMP_PTR(SkPath, &getPath());
DUMP_PTR(SkMatrix, getMatrix());
} break;
case RESTORE:
break;
case ROTATE:
DUMP_SCALAR(rotate);
break;
case SAVE:
DUMP_INT(SkCanvas::SaveFlags);
break;
case SAVE_LAYER: {
DUMP_RECT_PTR(layer);
DUMP_PTR(SkPaint, getPaint());
DUMP_INT(SkCanvas::SaveFlags);
} break;
case SCALE: {
DUMP_SCALAR(sx);
DUMP_SCALAR(sy);
} break;
case SKEW: {
DUMP_SCALAR(sx);
DUMP_SCALAR(sy);
} break;
case TRANSLATE: {
DUMP_SCALAR(dx);
DUMP_SCALAR(dy);
} break;
default:
SkASSERT(0);
}
SkDebugf("%s\n", buffer);
}
}
void SkPicturePlayback::dump() const {
char pBuffer[DUMP_BUFFER_SIZE];
char* bufferPtr = pBuffer;
int index;
if (fBitmapCount > 0)
SkDebugf("// bitmaps (%d)\n", fBitmapCount);
for (index = 0; index < fBitmapCount; index++) {
const SkBitmap& bitmap = fBitmaps[index];
dumpBitmap(bitmap);
}
if (fBitmapCount > 0)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Bitmaps bitmaps = {");
for (index = 0; index < fBitmapCount; index++)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"bitmap%p, ", &fBitmaps[index]);
if (fBitmapCount > 0)
SkDebugf("%s0};\n", pBuffer);
if (fMatrixCount > 0)
SkDebugf("// matrices (%d)\n", fMatrixCount);
for (index = 0; index < fMatrixCount; index++) {
const SkMatrix& matrix = fMatrices[index];
dumpMatrix(matrix);
}
bufferPtr = pBuffer;
if (fMatrixCount > 0)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Matrices matrices = {");
for (index = 0; index < fMatrixCount; index++)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"matrix%p, ", &fMatrices[index]);
if (fMatrixCount > 0)
SkDebugf("%s0};\n", pBuffer);
if (fPaintCount > 0)
SkDebugf("// paints (%d)\n", fPaintCount);
for (index = 0; index < fPaintCount; index++) {
const SkPaint& paint = fPaints[index];
dumpPaint(paint);
}
bufferPtr = pBuffer;
if (fPaintCount > 0)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Paints paints = {");
for (index = 0; index < fPaintCount; index++)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"paint%p, ", &fPaints[index]);
if (fPaintCount > 0)
SkDebugf("%s0};\n", pBuffer);
for (index = 0; index < fPathCount; index++) {
const SkPath& path = fPaths[index];
dumpPath(path);
}
bufferPtr = pBuffer;
if (fPathCount > 0)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Paths paths = {");
for (index = 0; index < fPathCount; index++)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"path%p, ", &fPaths[index]);
if (fPathCount > 0)
SkDebugf("%s0};\n", pBuffer);
for (index = 0; index < fPictureCount; index++) {
dumpPicture(*fPictureRefs[index]);
}
bufferPtr = pBuffer;
if (fPictureCount > 0)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Pictures pictures = {");
for (index = 0; index < fPictureCount; index++)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"picture%p, ", fPictureRefs[index]);
if (fPictureCount > 0)
SkDebugf("%s0};\n", pBuffer);
for (index = 0; index < fRegionCount; index++) {
const SkRegion& region = fRegions[index];
dumpRegion(region);
}
bufferPtr = pBuffer;
if (fRegionCount > 0)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Regions regions = {");
for (index = 0; index < fRegionCount; index++)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"region%p, ", &fRegions[index]);
if (fRegionCount > 0)
SkDebugf("%s0};\n", pBuffer);
const_cast<SkPicturePlayback*>(this)->dumpStream();
}
#endif
| [
"stubma@gmail.com"
] | stubma@gmail.com |
8d8fabc25257ad794d904f54a55db624f4dedc48 | fc6d2022ba53a72c08154a83982bb3cc92ca7cfd | /CodeGen.cpp | fd079882cca2724aeee8183e1444cd063f75c6dd | [] | no_license | zhangxueliu/genSqlMapper | 975037246cb7ce760c05bd6e6a6dd17c2b7dcc96 | f6a9d924ab63f03151f20c43501d306be9a915a4 | refs/heads/master | 2020-03-18T17:58:12.573476 | 2018-05-27T16:37:47 | 2018-05-27T16:37:47 | 135,063,386 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,064 | cpp | // CodeGen.cpp : main source file for CodeGen.exe
//
#include "stdafx.h"
#include <atlframe.h>
#include <atlctrls.h>
#include <atldlgs.h>
#include "resource.h"
#include "MainDlg.h"
CAppModule _Module;
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR /*lpstrCmdLine*/, int /*nCmdShow*/)
{
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int nRet = 0;
// BLOCK: Run application
{
CMainDlg dlgMain;
nRet = (int)dlgMain.DoModal();
}
_Module.Term();
::CoUninitialize();
return nRet;
}
| [
"xpl149@126.com"
] | xpl149@126.com |
dfc41582b9d073b290b5c5f2b223735974797e48 | bbba82f21a77f8aaafdc2c20d8ea533b59d44129 | /Node.cpp | 98e898ee2edb2096878fcddd4671375267bafa54 | [] | no_license | klwolfe365/camelride167 | 47ad4df366693e190d1bdbf60878171a9589f711 | 15c209511ca39206616aa46a508987e10ae66f8d | refs/heads/master | 2021-01-19T04:34:49.610379 | 2016-06-23T06:10:14 | 2016-06-23T06:10:14 | 36,532,674 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 273 | cpp | //
// Node.cpp
// CSE167 Spring 2015 Starter Code
//
// Created by Karen Wolfe on 5/7/15.
// Copyright (c) 2015 RexWest. All rights reserved.
//
#include "Node.h"
#include "Matrix4.h"
Node::Node(){}
Node::~Node(){}
void Node::draw(Matrix4 c){}
void Node::update(){}
| [
"karen@wolfenet.org"
] | karen@wolfenet.org |
0cbd2ee826be7429c7475f09c2b713a9a5e4c25e | 3c3f398acb3e8fb32d3170bc2be2a5824fd670ed | /训练赛/博弈/Nim or not Nim.cpp | 10c30fa9d484dd1193ebd763a7a13e1b042f6325 | [] | no_license | im-cy/ACM-code | 07d808adae18e900cd6021363bcf40a5726381d5 | 5b766ced1636212da4427bc1d5bac7174f73f3af | refs/heads/master | 2022-11-23T20:56:37.786086 | 2020-07-20T15:06:18 | 2020-07-20T15:06:18 | 281,143,765 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 507 | cpp | /*
x % 4 == 0 -> sg[x] = x-1;
x % 4 == 1 or 2 -> sg[x] = x;
x % 4 == 3 -> sg[x] = x+1;
*/
#include<bits/stdc++.h>
using namespace std;
int getsg(int num)
{
if(num % 4 == 0)
return num - 1;
if(num % 4 == 3)
return num + 1;
return num;
}
int main()
{
int T;
scanf("%d",&T);
while(T --)
{
int n;
scanf("%d",&n);
int ans = 0;
for(int i = 1 ; i <= n ; i ++)
{
int num;
scanf("%d",&num);
ans ^= getsg(num);
}
if(ans)
puts("Alice");
else
puts("Bob");
}
return 0;
}
| [
"44048665+im-cy@users.noreply.github.com"
] | 44048665+im-cy@users.noreply.github.com |
6c8a46d0794f0e32c95547543515e0f1fed3da3c | ee507b3010c903ec716315f7df2ba4ef5ae5921a | /ui/DecorationManager.cpp | 15ae2009d1c5373b164703dcb0bcc0b2dbc6f473 | [] | no_license | sopyer/Shadowgrounds | ac6b281cd95d762096dfc04ddae70d3f3e63be05 | 691cb389c7d8121eda85ea73409bbbb74bfdb103 | refs/heads/master | 2020-03-29T18:25:48.103837 | 2017-06-24T17:08:50 | 2017-06-24T17:08:50 | 9,700,603 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,099 | cpp |
#include "precompiled.h"
#ifdef _MSC_VER
#pragma warning(disable:4103)
#pragma warning(disable:4786)
#endif
#include "DecorationManager.h"
#include "Decoration.h"
#include "VisualObject.h"
#include "../container/LinkedList.h"
#include "../util/ColorMap.h"
#include "../system/Logger.h"
namespace ui
{
DecorationManager::DecorationManager()
{
decorList = new LinkedList();
}
DecorationManager::~DecorationManager()
{
while (!decorList->isEmpty())
{
Decoration *d = (Decoration *)decorList->popLast();
delete d;
}
delete decorList;
}
Decoration *DecorationManager::createDecoration()
{
Decoration *decor = new Decoration();
decorList->append(decor);
return decor;
}
void DecorationManager::deleteDecoration(Decoration *decoration)
{
decorList->remove(decoration);
delete decoration;
}
Decoration *DecorationManager::getDecorationByName(const char *name) const
{
LinkedListIterator iter = LinkedListIterator(decorList);
while (iter.iterateAvailable())
{
Decoration *decor = (Decoration *)iter.iterateNext();
if (decor->name != NULL && strcmp(decor->name, name) == 0)
{
return decor;
}
}
return NULL;
}
void DecorationManager::run()
{
LinkedListIterator iter = LinkedListIterator(decorList);
while (iter.iterateAvailable())
{
Decoration *decor = (Decoration *)iter.iterateNext();
decor->run();
}
}
void DecorationManager::synchronizeAllDecorations() const
{
LinkedListIterator iter = LinkedListIterator(decorList);
while (iter.iterateAvailable())
{
Decoration *decor = (Decoration *)iter.iterateNext();
for (int i = 0; i < DECORATION_MAX_EFFECTS; i++)
decor->effectValue[i] = 0;
}
}
void DecorationManager::updateDecorationIllumination(util::ColorMap *colorMap)
{
LinkedListIterator iter = LinkedListIterator(decorList);
while (iter.iterateAvailable())
{
Decoration *decor = (Decoration *)iter.iterateNext();
if (decor->getVisualObject() != NULL)
{
VC3 pos = decor->getPosition();
COL col = colorMap->getColorAtScaled(pos.x, pos.z);
decor->getVisualObject()->setSelfIllumination(col);
}
}
}
int DecorationManager::getIdForDecoration(Decoration *decor)
{
assert(decor != NULL);
int i = DECORID_LOWEST_POSSIBLE_VALUE;
LinkedListIterator iter(decorList);
while (iter.iterateAvailable())
{
Decoration *d = (Decoration *)iter.iterateNext();
if (decor == d) return i;
i++;
}
assert(!"DecorationManager::getIdForDecoration - Unable to solve an id for given decoration.");
return 0;
}
Decoration *DecorationManager::getDecorationById(int id)
{
int i = DECORID_LOWEST_POSSIBLE_VALUE;
LinkedListIterator iter(decorList);
while (iter.iterateAvailable())
{
Decoration *d = (Decoration *)iter.iterateNext();
if (i == id) return d;
i++;
}
Logger::getInstance()->debug("DecorationManager::getDecorationById - Given id did not match any decoration.");
//assert(!"DecorationManager::getDecorationById - Given id did not match any decoration.");
return NULL;
}
}
| [
"sopyer@gmail.com"
] | sopyer@gmail.com |
d0de753dac09d7a39af1f798b0137b457612620a | 55f001f44ae63c17c3182ddda4242d83faa4b62f | /Libraries/orocos_kdl/kdl/framevel.hpp | f0b2ada558aebf79c84d593453401b939e732242 | [] | no_license | fuzzyTew/toywalker | ab8ff51c1667f7d55ea106611cad86b90b966be9 | 4bd6420bfd83848b4f0f93d2fd7c1e7114056b47 | refs/heads/master | 2020-12-14T07:27:14.923122 | 2017-07-27T22:13:40 | 2017-07-27T22:13:40 | 95,554,504 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 57 | hpp | ../orocos_kinematics_dynamics/orocos_kdl/src/framevel.hpp | [
"fuzzyTew@gmail.com"
] | fuzzyTew@gmail.com |
56dfb121e3e4d5918f8e081115e05de2b0862489 | bd779bc3c5de1eff981ce9ed17f46cc5dd51d324 | /Engine_structs.h | 537e9971df91336f80d6d2ef99c6bcf3eaf86430 | [] | no_license | Skengdo/Beyond-The-Wire-SDK | 78ee98559928e97241662a3ecacd276948ba5ba5 | 45c358fcdcec7f85aa2db85041fb8d407b28a589 | refs/heads/main | 2022-12-28T14:34:28.540993 | 2020-10-21T18:10:52 | 2020-10-21T18:10:52 | 306,109,084 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 948,917 | h | #pragma once
// Name: novojogo, Version: 45
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
/*!!HELPER_DEF!!*/
/*!!DEFINE!!*/
namespace UFT
{
//---------------------------------------------------------------------------
// Enums
//---------------------------------------------------------------------------
// Enum Engine.ETranslucencyType
enum class ETranslucencyType : uint8_t
{
Raster = 0,
RayTracing = 1,
MAX = 2,
};
// Enum Engine.EReflectionsType
enum class EReflectionsType : uint8_t
{
ScreenSpace = 0,
RayTracing = 1,
MAX = 2,
};
// Enum Engine.EAutoExposureMethod
enum class EAutoExposureMethod : uint8_t
{
AEM_Histogram = 0,
AEM_Basic = 1,
AEM_Manual = 2,
AEM_MAX = 3,
};
// Enum Engine.EBloomMethod
enum class EBloomMethod : uint8_t
{
BM_SOG = 0,
BM_FFT = 1,
BM_MAX = 2,
};
// Enum Engine.EBlendMode
enum class EBlendMode : uint8_t
{
BLEND_Opaque = 0,
BLEND_Masked = 1,
BLEND_Translucent = 2,
BLEND_Additive = 3,
BLEND_Modulate = 4,
BLEND_AlphaComposite = 5,
BLEND_AlphaHoldout = 6,
BLEND_MAX = 7,
};
// Enum Engine.EMouseLockMode
enum class EMouseLockMode : uint8_t
{
DoNotLock = 0,
LockOnCapture = 1,
LockAlways = 2,
LockInFullscreen = 3,
MAX = 4,
};
// Enum Engine.EWindowTitleBarMode
enum class EWindowTitleBarMode : uint8_t
{
Overlay = 0,
VerticalBox = 1,
MAX = 2,
};
// Enum Engine.EInputEvent
enum class EInputEvent : uint8_t
{
IE_Pressed = 0,
IE_Released = 1,
IE_Repeat = 2,
IE_DoubleClick = 3,
IE_Axis = 4,
IE_MAX = 5,
};
// Enum Engine.ERelativeTransformSpace
enum class ERelativeTransformSpace : uint8_t
{
RTS_World = 0,
RTS_Actor = 1,
RTS_Component = 2,
RTS_ParentBoneSpace = 3,
RTS_MAX = 4,
};
// Enum Engine.EComponentMobility
enum class EComponentMobility : uint8_t
{
Static = 0,
Stationary = 1,
Movable = 2,
MAX = 3,
};
// Enum Engine.EDetailMode
enum class EDetailMode : uint8_t
{
DM_Low = 0,
DM_Medium = 1,
DM_High = 2,
DM_MAX = 3,
};
// Enum Engine.ERadialImpulseFalloff
enum class ERadialImpulseFalloff : uint8_t
{
RIF_Constant = 0,
RIF_Linear = 1,
RIF_MAX = 2,
};
// Enum Engine.ECollisionEnabled
enum class ECollisionEnabled : uint8_t
{
NoCollision = 0,
QueryOnly = 1,
PhysicsOnly = 2,
QueryAndPhysics = 3,
MAX = 4,
};
// Enum Engine.ECollisionChannel
enum class ECollisionChannel : uint8_t
{
ECC_WorldStatic = 0,
ECC_WorldDynamic = 1,
ECC_Pawn = 2,
ECC_Visibility = 3,
ECC_Camera = 4,
ECC_PhysicsBody = 5,
ECC_Vehicle = 6,
ECC_Destructible = 7,
ECC_EngineTraceChannel1 = 8,
ECC_EngineTraceChannel2 = 9,
ECC_EngineTraceChannel3 = 10,
ECC_EngineTraceChannel4 = 11,
ECC_EngineTraceChannel5 = 12,
ECC_EngineTraceChannel6 = 13,
ECC_GameTraceChannel1 = 14,
ECC_GameTraceChannel2 = 15,
ECC_GameTraceChannel3 = 16,
ECC_GameTraceChannel4 = 17,
ECC_GameTraceChannel5 = 18,
ECC_GameTraceChannel6 = 19,
ECC_GameTraceChannel7 = 20,
ECC_GameTraceChannel8 = 21,
ECC_GameTraceChannel9 = 22,
ECC_GameTraceChannel10 = 23,
ECC_GameTraceChannel11 = 24,
ECC_GameTraceChannel12 = 25,
ECC_GameTraceChannel13 = 26,
ECC_GameTraceChannel14 = 27,
ECC_GameTraceChannel15 = 28,
ECC_GameTraceChannel16 = 29,
ECC_GameTraceChannel17 = 30,
ECC_GameTraceChannel18 = 31,
ECC_OverlapAll_Deprecated = 32,
ECC_MAX = 33,
};
// Enum Engine.ECollisionResponse
enum class ECollisionResponse : uint8_t
{
ECR_Ignore = 0,
ECR_Overlap = 1,
ECR_Block = 2,
ECR_MAX = 3,
};
// Enum Engine.EWalkableSlopeBehavior
enum class EWalkableSlopeBehavior : uint8_t
{
WalkableSlope_Default = 0,
WalkableSlope_Increase = 1,
WalkableSlope_Decrease = 2,
WalkableSlope_Unwalkable = 3,
WalkableSlope_Max = 4,
};
// Enum Engine.EDOFMode
enum class EDOFMode : uint8_t
{
Default = 0,
SixDOF = 1,
YZPlane = 2,
XZPlane = 3,
XYPlane = 4,
CustomPlane = 5,
None = 6,
MAX = 7,
};
// Enum Engine.ERendererStencilMask
enum class ERendererStencilMask : uint8_t
{
ERSM_Default = 0,
ERSM = 1,
ERSM01 = 2,
ERSM02 = 3,
ERSM03 = 4,
ERSM04 = 5,
ERSM05 = 6,
ERSM06 = 7,
ERSM07 = 8,
ERSM08 = 9,
ERSM_MAX = 10,
};
// Enum Engine.ESleepFamily
enum class ESleepFamily : uint8_t
{
Normal = 0,
Sensitive = 1,
Custom = 2,
MAX = 3,
};
// Enum Engine.ERuntimeVirtualTextureMainPassType
enum class ERuntimeVirtualTextureMainPassType : uint8_t
{
Never = 0,
Exclusive = 1,
Always = 2,
MAX = 3,
};
// Enum Engine.ECanBeCharacterBase
enum class ECanBeCharacterBase : uint8_t
{
ECB_No = 0,
ECB_Yes = 1,
ECB_Owner = 2,
ECB_MAX = 3,
};
// Enum Engine.EHasCustomNavigableGeometry
enum class EHasCustomNavigableGeometry : uint8_t
{
No = 0,
Yes = 1,
EvenIfNotCollidable = 2,
DontExport = 3,
MAX = 4,
};
// Enum Engine.ELightmapType
enum class ELightmapType : uint8_t
{
Default = 0,
ForceSurface = 1,
ForceVolumetric = 2,
MAX = 3,
};
// Enum Engine.EIndirectLightingCacheQuality
enum class EIndirectLightingCacheQuality : uint8_t
{
ILCQ_Off = 0,
ILCQ_Point = 1,
ILCQ_Volume = 2,
ILCQ_MAX = 3,
};
// Enum Engine.ESceneDepthPriorityGroup
enum class ESceneDepthPriorityGroup : uint8_t
{
SDPG_World = 0,
SDPG_Foreground = 1,
SDPG_MAX = 2,
};
// Enum Engine.EAlphaBlendOption
enum class EAlphaBlendOption : uint8_t
{
Linear = 0,
Cubic = 1,
HermiteCubic = 2,
Sinusoidal = 3,
QuadraticInOut = 4,
CubicInOut = 5,
QuarticInOut = 6,
QuinticInOut = 7,
CircularIn = 8,
CircularOut = 9,
CircularInOut = 10,
ExpIn = 11,
ExpOut = 12,
ExpInOut = 13,
Custom = 14,
MAX = 15,
};
// Enum Engine.EAnimGroupRole
enum class EAnimGroupRole : uint8_t
{
CanBeLeader = 0,
AlwaysFollower = 1,
AlwaysLeader = 2,
TransitionLeader = 3,
TransitionFollower = 4,
MAX = 5,
};
// Enum Engine.AnimationKeyFormat
enum class EAnimationKeyFormat : uint8_t
{
AKF_ConstantKeyLerp = 0,
AKF_VariableKeyLerp = 1,
AKF_PerTrackCompression = 2,
AKF_MAX = 3,
};
// Enum Engine.ERawCurveTrackTypes
enum class ERawCurveTrackTypes : uint8_t
{
RCT_Float = 0,
RCT_Vector = 1,
RCT_Transform = 2,
RCT_MAX = 3,
};
// Enum Engine.EAnimAssetCurveFlags
enum class EAnimAssetCurveFlags : uint8_t
{
AACF_DriveMorphTarget_DEPRECATED = 0,
AACF_DriveAttribute_DEPRECATED = 1,
AACF_Editable = 2,
AACF_DriveMaterial_DEPRECATED = 3,
AACF_Metadata = 4,
AACF_DriveTrack = 5,
AACF_Disabled = 6,
AACF_MAX = 7,
};
// Enum Engine.AnimationCompressionFormat
enum class EAnimationCompressionFormat : uint8_t
{
ACF_None = 0,
ACF_Float96NoW = 1,
ACF_Fixed48NoW = 2,
ACF_IntervalFixed32NoW = 3,
ACF_Fixed32NoW = 4,
ACF_Float32NoW = 5,
ACF_Identity = 6,
ACF_MAX = 7,
};
// Enum Engine.EAdditiveBasePoseType
enum class EAdditiveBasePoseType : uint8_t
{
ABPT_None = 0,
ABPT_RefPose = 1,
ABPT_AnimScaled = 2,
ABPT_AnimFrame = 3,
ABPT_MAX = 4,
};
// Enum Engine.ERootMotionMode
enum class ERootMotionMode : uint8_t
{
NoRootMotionExtraction = 0,
IgnoreRootMotion = 1,
RootMotionFromEverything = 2,
RootMotionFromMontagesOnly = 3,
MAX = 4,
};
// Enum Engine.ERootMotionRootLock
enum class ERootMotionRootLock : uint8_t
{
RefPose = 0,
AnimFirstFrame = 1,
Zero = 2,
MAX = 3,
};
// Enum Engine.EMontagePlayReturnType
enum class EMontagePlayReturnType : uint8_t
{
MontageLength = 0,
Duration = 1,
MAX = 2,
};
// Enum Engine.EDrawDebugItemType
enum class EDrawDebugItemType : uint8_t
{
DirectionalArrow = 0,
Sphere = 1,
Line = 2,
OnScreenMessage = 3,
CoordinateSystem = 4,
MAX = 5,
};
// Enum Engine.EAnimLinkMethod
enum class EAnimLinkMethod : uint8_t
{
Absolute = 0,
Relative = 1,
Proportional = 2,
MAX = 3,
};
// Enum Engine.EMontageSubStepResult
enum class EMontageSubStepResult : uint8_t
{
Moved = 0,
NotMoved = 1,
InvalidSection = 2,
InvalidMontage = 3,
MAX = 4,
};
// Enum Engine.EAnimNotifyEventType
enum class EAnimNotifyEventType : uint8_t
{
Begin = 0,
End = 1,
MAX = 2,
};
// Enum Engine.EEvaluatorMode
enum class EEvaluatorMode : uint8_t
{
EM_Standard = 0,
EM_Freeze = 1,
EM_DelayedFreeze = 2,
EM_MAX = 3,
};
// Enum Engine.EEvaluatorDataSource
enum class EEvaluatorDataSource : uint8_t
{
EDS_SourcePose = 0,
EDS_DestinationPose = 1,
EDS_MAX = 2,
};
// Enum Engine.ECopyType
enum class ECopyType : uint8_t
{
MemCopy = 0,
BoolProperty = 1,
StructProperty = 2,
ObjectProperty = 3,
MAX = 4,
};
// Enum Engine.EPostCopyOperation
enum class EPostCopyOperation : uint8_t
{
None = 0,
LogicalNegateBool = 1,
MAX = 2,
};
// Enum Engine.EPinHidingMode
enum class EPinHidingMode : uint8_t
{
NeverAsPin = 0,
PinHiddenByDefault = 1,
PinShownByDefault = 2,
AlwaysAsPin = 3,
MAX = 4,
};
// Enum Engine.AnimPhysCollisionType
enum class EAnimPhysCollisionType : uint8_t
{
AnimPhysCollisionType__CoM = 0,
AnimPhysCollisionType__CustomSphere = 1,
AnimPhysCollisionType__InnerSphere = 2,
AnimPhysCollisionType__OuterSphere = 3,
AnimPhysCollisionType__AnimPhysCollisionType_MAX = 4,
};
// Enum Engine.AnimPhysTwistAxis
enum class EAnimPhysTwistAxis : uint8_t
{
AnimPhysTwistAxis__AxisX = 0,
AnimPhysTwistAxis__AxisY = 1,
AnimPhysTwistAxis__AxisZ = 2,
AnimPhysTwistAxis__AnimPhysTwistAxis_MAX = 3,
};
// Enum Engine.ETypeAdvanceAnim
enum class ETypeAdvanceAnim : uint8_t
{
ETAA_Default = 0,
ETAA_Finished = 1,
ETAA_Looped = 2,
ETAA_MAX = 3,
};
// Enum Engine.ETransitionLogicType
enum class ETransitionLogicType : uint8_t
{
TLT_StandardBlend = 0,
TLT_Custom = 1,
TLT_MAX = 2,
};
// Enum Engine.ETransitionBlendMode
enum class ETransitionBlendMode : uint8_t
{
TBM_Linear = 0,
TBM_Cubic = 1,
TBM_MAX = 2,
};
// Enum Engine.EComponentType
enum class EComponentType : uint8_t
{
None = 0,
TranslationX = 1,
TranslationY = 2,
TranslationZ = 3,
RotationX = 4,
RotationY = 5,
RotationZ = 6,
Scale = 7,
ScaleX = 8,
ScaleY = 9,
ScaleZ = 10,
MAX = 11,
};
// Enum Engine.EAxisOption
enum class EAxisOption : uint8_t
{
X = 0,
Y = 1,
Z = 2,
X_Neg = 3,
Y_Neg = 4,
Z_Neg = 5,
Custom = 6,
MAX = 7,
};
// Enum Engine.EAnimInterpolationType
enum class EAnimInterpolationType : uint8_t
{
Linear = 0,
Step = 1,
MAX = 2,
};
// Enum Engine.ECurveBlendOption
enum class ECurveBlendOption : uint8_t
{
MaxWeight = 0,
NormalizeByWeight = 1,
BlendByWeight = 2,
MAX = 3,
};
// Enum Engine.EAdditiveAnimationType
enum class EAdditiveAnimationType : uint8_t
{
AAT_None = 0,
AAT_LocalSpaceBase = 1,
AAT_RotationOffsetMeshSpace = 2,
AAT_MAX = 3,
};
// Enum Engine.ENotifyFilterType
enum class ENotifyFilterType : uint8_t
{
NoFiltering = 0,
LOD = 1,
MAX = 2,
};
// Enum Engine.EMontageNotifyTickType
enum class EMontageNotifyTickType : uint8_t
{
Queued = 0,
BranchingPoint = 1,
MAX = 2,
};
// Enum Engine.EBoneRotationSource
enum class EBoneRotationSource : uint8_t
{
BRS_KeepComponentSpaceRotation = 0,
BRS_KeepLocalSpaceRotation = 1,
BRS_CopyFromTarget = 2,
BRS_MAX = 3,
};
// Enum Engine.EBoneControlSpace
enum class EBoneControlSpace : uint8_t
{
BCS_WorldSpace = 0,
BCS_ComponentSpace = 1,
BCS_ParentBoneSpace = 2,
BCS_BoneSpace = 3,
BCS_MAX = 4,
};
// Enum Engine.EBoneAxis
enum class EBoneAxis : uint8_t
{
BA_X = 0,
BA_Y = 1,
BA_Z = 2,
BA_MAX = 3,
};
// Enum Engine.EPrimaryAssetCookRule
enum class EPrimaryAssetCookRule : uint8_t
{
Unknown = 0,
NeverCook = 1,
DevelopmentCook = 2,
DevelopmentAlwaysCook = 3,
AlwaysCook = 4,
MAX = 5,
};
// Enum Engine.EAttenuationShape
enum class EAttenuationShape : uint8_t
{
Sphere = 0,
Capsule = 1,
Box = 2,
Cone = 3,
MAX = 4,
};
// Enum Engine.EAttenuationDistanceModel
enum class EAttenuationDistanceModel : uint8_t
{
Linear = 0,
Logarithmic = 1,
Inverse = 2,
LogReverse = 3,
NaturalSound = 4,
Custom = 5,
MAX = 6,
};
// Enum Engine.EMonoChannelUpmixMethod
enum class EMonoChannelUpmixMethod : uint8_t
{
Linear = 0,
EqualPower = 1,
FullVolume = 2,
MAX = 3,
};
// Enum Engine.EPanningMethod
enum class EPanningMethod : uint8_t
{
Linear = 0,
EqualPower = 1,
MAX = 2,
};
// Enum Engine.EVoiceSampleRate
enum class EVoiceSampleRate : uint8_t
{
Low16000Hz = 0,
Normal24000Hz = 1,
MAX = 2,
};
// Enum Engine.ReverbPreset
enum class EReverbPreset : uint8_t
{
REVERB_Default = 0,
REVERB_Bathroom = 1,
REVERB_StoneRoom = 2,
REVERB_Auditorium = 3,
REVERB_ConcertHall = 4,
REVERB_Cave = 5,
REVERB_Hallway = 6,
REVERB_StoneCorridor = 7,
REVERB_Alley = 8,
REVERB_Forest = 9,
REVERB_City = 10,
REVERB_Mountains = 11,
REVERB_Quarry = 12,
REVERB_Plain = 13,
REVERB_ParkingLot = 14,
REVERB_SewerPipe = 15,
REVERB_Underwater = 16,
REVERB_SmallRoom = 17,
REVERB_MediumRoom = 18,
REVERB_LargeRoom = 19,
REVERB_MediumHall = 20,
REVERB_LargeHall = 21,
REVERB_Plate = 22,
REVERB_MAX = 23,
};
// Enum Engine.EBlendableLocation
enum class EBlendableLocation : uint8_t
{
BL_AfterTonemapping = 0,
BL_BeforeTonemapping = 1,
BL_BeforeTranslucency = 2,
BL_ReplacingTonemapper = 3,
BL_SSRInput = 4,
BL_MAX = 5,
};
// Enum Engine.ENotifyTriggerMode
enum class ENotifyTriggerMode : uint8_t
{
AllAnimations = 0,
HighestWeightedAnimation = 1,
None = 2,
MAX = 3,
};
// Enum Engine.EBlendSpaceAxis
enum class EBlendSpaceAxis : uint8_t
{
BSA_None = 0,
BSA_X = 1,
BSA_Y = 2,
BSA_Max = 3,
};
// Enum Engine.EBlueprintNativizationFlag
enum class EBlueprintNativizationFlag : uint8_t
{
Disabled = 0,
Dependency = 1,
ExplicitlyEnabled = 2,
MAX = 3,
};
// Enum Engine.EBlueprintCompileMode
enum class EBlueprintCompileMode : uint8_t
{
Default = 0,
Development = 1,
FinalRelease = 2,
MAX = 3,
};
// Enum Engine.EBlueprintType
enum class EBlueprintType : uint8_t
{
BPTYPE_Normal = 0,
BPTYPE_Const = 1,
BPTYPE_MacroLibrary = 2,
BPTYPE_Interface = 3,
BPTYPE_LevelScript = 4,
BPTYPE_FunctionLibrary = 5,
BPTYPE_MAX = 6,
};
// Enum Engine.EBlueprintStatus
enum class EBlueprintStatus : uint8_t
{
BS_Unknown = 0,
BS_Dirty = 1,
BS_Error = 2,
BS_UpToDate = 3,
BS_BeingCreated = 4,
BS_UpToDateWithWarnings = 5,
BS_MAX = 6,
};
// Enum Engine.EBodyCollisionResponse
enum class EBodyCollisionResponse : uint8_t
{
BodyCollision_Enabled = 0,
BodyCollision_Disabled = 1,
BodyCollision_MAX = 2,
};
// Enum Engine.EPhysicsType
enum class EPhysicsType : uint8_t
{
PhysType_Default = 0,
PhysType_Kinematic = 1,
PhysType_Simulated = 2,
PhysType_MAX = 3,
};
// Enum Engine.ECollisionTraceFlag
enum class ECollisionTraceFlag : uint8_t
{
CTF_UseDefault = 0,
CTF_UseSimpleAndComplex = 1,
CTF_UseSimpleAsComplex = 2,
CTF_UseComplexAsSimple = 3,
CTF_MAX = 4,
};
// Enum Engine.EBrushType
enum class EBrushType : uint8_t
{
Brush_Default = 0,
Brush_Add = 1,
Brush_Subtract = 2,
Brush_MAX = 3,
};
// Enum Engine.ECsgOper
enum class ECsgOper : uint8_t
{
CSG_Active = 0,
CSG_Add = 1,
CSG_Subtract = 2,
CSG_Intersect = 3,
CSG_Deintersect = 4,
CSG_None = 5,
CSG_MAX = 6,
};
// Enum Engine.EInitialOscillatorOffset
enum class EInitialOscillatorOffset : uint8_t
{
EOO_OffsetRandom = 0,
EOO_OffsetZero = 1,
EOO_MAX = 2,
};
// Enum Engine.EOscillatorWaveform
enum class EOscillatorWaveform : uint8_t
{
SineWave = 0,
PerlinNoise = 1,
MAX = 2,
};
// Enum Engine.ECameraAlphaBlendMode
enum class ECameraAlphaBlendMode : uint8_t
{
CABM_Linear = 0,
CABM_Cubic = 1,
CABM_MAX = 2,
};
// Enum Engine.ECameraAnimPlaySpace
enum class ECameraAnimPlaySpace : uint8_t
{
CameraLocal = 0,
World = 1,
UserDefined = 2,
MAX = 3,
};
// Enum Engine.ECameraProjectionMode
enum class ECameraProjectionMode : uint8_t
{
Perspective = 0,
Orthographic = 1,
MAX = 2,
};
// Enum Engine.ECloudStorageDelegate
enum class ECloudStorageDelegate : uint8_t
{
CSD_KeyValueReadComplete = 0,
CSD_KeyValueWriteComplete = 1,
CSD_ValueChanged = 2,
CSD_DocumentQueryComplete = 3,
CSD_DocumentReadComplete = 4,
CSD_DocumentWriteComplete = 5,
CSD_DocumentConflictDetected = 6,
CSD_MAX = 7,
};
// Enum Engine.EAngularDriveMode
enum class EAngularDriveMode : uint8_t
{
SLERP = 0,
TwistAndSwing = 1,
MAX = 2,
};
// Enum Engine.ELinearConstraintMotion
enum class ELinearConstraintMotion : uint8_t
{
LCM_Free = 0,
LCM_Limited = 1,
LCM_Locked = 2,
LCM_MAX = 3,
};
// Enum Engine.ECurveTableMode
enum class ECurveTableMode : uint8_t
{
Empty = 0,
SimpleCurves = 1,
RichCurves = 2,
MAX = 3,
};
// Enum Engine.EEvaluateCurveTableResult
enum class EEvaluateCurveTableResult : uint8_t
{
RowFound = 0,
RowNotFound = 1,
MAX = 2,
};
// Enum Engine.EGrammaticalNumber
enum class EGrammaticalNumber : uint8_t
{
Singular = 0,
Plural = 1,
MAX = 2,
};
// Enum Engine.EGrammaticalGender
enum class EGrammaticalGender : uint8_t
{
Neuter = 0,
Masculine = 1,
Feminine = 2,
Mixed = 3,
MAX = 4,
};
// Enum Engine.DistributionParamMode
enum class EDistributionParamMode : uint8_t
{
DPM_Normal = 0,
DPM_Abs = 1,
DPM_Direct = 2,
DPM_MAX = 3,
};
// Enum Engine.EDistributionVectorMirrorFlags
enum class EDistributionVectorMirrorFlags : uint8_t
{
EDVMF_Same = 0,
EDVMF_Different = 1,
EDVMF_Mirror = 2,
EDVMF_MAX = 3,
};
// Enum Engine.EDistributionVectorLockFlags
enum class EDistributionVectorLockFlags : uint8_t
{
EDVLF_None = 0,
EDVLF_XY = 1,
EDVLF_XZ = 2,
EDVLF_YZ = 3,
EDVLF_XYZ = 4,
EDVLF_MAX = 5,
};
// Enum Engine.ENodeEnabledState
enum class ENodeEnabledState : uint8_t
{
Enabled = 0,
Disabled = 1,
DevelopmentOnly = 2,
MAX = 3,
};
// Enum Engine.ENodeAdvancedPins
enum class ENodeAdvancedPins : uint8_t
{
NoPins = 0,
Shown = 1,
Hidden = 2,
MAX = 3,
};
// Enum Engine.ENodeTitleType
enum class ENodeTitleType : uint8_t
{
FullTitle = 0,
ListView = 1,
EditableTitle = 2,
MenuTitle = 3,
MAX_TitleTypes = 4,
MAX = 5,
};
// Enum Engine.EPinContainerType
enum class EPinContainerType : uint8_t
{
None = 0,
Array = 1,
Set = 2,
Map = 3,
MAX = 4,
};
// Enum Engine.EEdGraphPinDirection
enum class EEdGraphPinDirection : uint8_t
{
EGPD_Input = 0,
EGPD_Output = 1,
EGPD_MAX = 2,
};
// Enum Engine.EBlueprintPinStyleType
enum class EBlueprintPinStyleType : uint8_t
{
BPST_Original = 0,
BPST_VariantA = 1,
BPST_MAX = 2,
};
// Enum Engine.ECanCreateConnectionResponse
enum class ECanCreateConnectionResponse : uint8_t
{
CONNECT_RESPONSE_MAKE = 0,
CONNECT_RESPONSE_DISALLOW = 1,
CONNECT_RESPONSE_BREAK_OTHERS_A = 2,
CONNECT_RESPONSE_BREAK_OTHERS_B = 3,
CONNECT_RESPONSE_BREAK_OTHERS_AB = 4,
CONNECT_RESPONSE_MAKE_WITH_CONVERSION_NODE = 5,
CONNECT_RESPONSE_MAX = 6,
};
// Enum Engine.EGraphType
enum class EGraphType : uint8_t
{
GT_Function = 0,
GT_Ubergraph = 1,
GT_Macro = 2,
GT_Animation = 3,
GT_StateMachine = 4,
GT_MAX = 5,
};
// Enum Engine.EConsoleType
enum class EConsoleType : uint8_t
{
Any = 0,
Mobile = 1,
MAX = 2,
};
// Enum Engine.ETransitionType
enum class ETransitionType : uint8_t
{
None = 0,
Paused = 1,
Loading = 2,
Saving = 3,
Connecting = 4,
Precaching = 5,
WaitingToConnect = 6,
MAX = 7,
};
// Enum Engine.EFullyLoadPackageType
enum class EFullyLoadPackageType : uint8_t
{
FULLYLOAD_Map = 0,
FULLYLOAD_Game_PreLoadClass = 1,
FULLYLOAD_Game_PostLoadClass = 2,
FULLYLOAD_Always = 3,
FULLYLOAD_Mutator = 4,
FULLYLOAD_MAX = 5,
};
// Enum Engine.EViewModeIndex
enum class EViewModeIndex : uint8_t
{
VMI_BrushWireframe = 0,
VMI_Wireframe = 1,
VMI_Unlit = 2,
VMI_Lit = 3,
VMI_Lit_DetailLighting = 4,
VMI_LightingOnly = 5,
VMI_LightComplexity = 6,
VMI_ShaderComplexity = 7,
VMI_LightmapDensity = 8,
VMI_LitLightmapDensity = 9,
VMI_ReflectionOverride = 10,
VMI_VisualizeBuffer = 11,
VMI_StationaryLightOverlap = 12,
VMI_CollisionPawn = 13,
VMI_CollisionVisibility = 14,
VMI_LODColoration = 15,
VMI_QuadOverdraw = 16,
VMI_PrimitiveDistanceAccuracy = 17,
VMI_MeshUVDensityAccuracy = 18,
VMI_ShaderComplexityWithQuadOverdraw = 19,
VMI_HLODColoration = 20,
VMI_GroupLODColoration = 21,
VMI_MaterialTextureScaleAccuracy = 22,
VMI_RequiredTextureResolution = 23,
VMI_PathTracing = 24,
VMI_RayTracingDebug = 25,
VMI_Max = 26,
VMI_Unknown = 27,
};
// Enum Engine.EDemoPlayFailure
enum class EDemoPlayFailure : uint8_t
{
Generic = 0,
DemoNotFound = 1,
Corrupt = 2,
InvalidVersion = 3,
InitBase = 4,
GameSpecificHeader = 5,
ReplayStreamerInternal = 6,
LoadMap = 7,
Serialization = 8,
MAX = 9,
};
// Enum Engine.ETravelType
enum class ETravelType : uint8_t
{
TRAVEL_Absolute = 0,
TRAVEL_Partial = 1,
TRAVEL_Relative = 2,
TRAVEL_MAX = 3,
};
// Enum Engine.ENetworkLagState
enum class ENetworkLagState : uint8_t
{
NotLagging = 0,
Lagging = 1,
MAX = 2,
};
// Enum Engine.EMouseCaptureMode
enum class EMouseCaptureMode : uint8_t
{
NoCapture = 0,
CapturePermanently = 1,
CapturePermanently_IncludingInitialMouseDown = 2,
CaptureDuringMouseDown = 3,
CaptureDuringRightMouseDown = 4,
MAX = 5,
};
// Enum Engine.ECustomTimeStepSynchronizationState
enum class ECustomTimeStepSynchronizationState : uint8_t
{
Closed = 0,
Error = 1,
Synchronized = 2,
Synchronizing = 3,
MAX = 4,
};
// Enum Engine.EMeshBufferAccess
enum class EMeshBufferAccess : uint8_t
{
Default = 0,
ForceCPUAndGPU = 1,
MAX = 2,
};
// Enum Engine.EConstraintFrame
enum class EConstraintFrame : uint8_t
{
Frame1 = 0,
Frame2 = 1,
MAX = 2,
};
// Enum Engine.EAngularConstraintMotion
enum class EAngularConstraintMotion : uint8_t
{
ACM_Free = 0,
ACM_Limited = 1,
ACM_Locked = 2,
ACM_MAX = 3,
};
// Enum Engine.EComponentSocketType
enum class EComponentSocketType : uint8_t
{
Invalid = 0,
Bone = 1,
Socket = 2,
MAX = 3,
};
// Enum Engine.EPhysicalSurface
enum class EPhysicalSurface : uint8_t
{
SurfaceType_Default = 0,
SurfaceType1 = 1,
SurfaceType2 = 2,
SurfaceType3 = 3,
SurfaceType4 = 4,
SurfaceType5 = 5,
SurfaceType6 = 6,
SurfaceType7 = 7,
SurfaceType8 = 8,
SurfaceType9 = 9,
SurfaceType10 = 10,
SurfaceType11 = 11,
SurfaceType12 = 12,
SurfaceType13 = 13,
SurfaceType14 = 14,
SurfaceType15 = 15,
SurfaceType16 = 16,
SurfaceType17 = 17,
SurfaceType18 = 18,
SurfaceType19 = 19,
SurfaceType20 = 20,
SurfaceType21 = 21,
SurfaceType22 = 22,
SurfaceType23 = 23,
SurfaceType24 = 24,
SurfaceType25 = 25,
SurfaceType26 = 26,
SurfaceType27 = 27,
SurfaceType28 = 28,
SurfaceType29 = 29,
SurfaceType30 = 30,
SurfaceType31 = 31,
SurfaceType32 = 32,
SurfaceType33 = 33,
SurfaceType34 = 34,
SurfaceType35 = 35,
SurfaceType36 = 36,
SurfaceType37 = 37,
SurfaceType38 = 38,
SurfaceType39 = 39,
SurfaceType40 = 40,
SurfaceType41 = 41,
SurfaceType42 = 42,
SurfaceType43 = 43,
SurfaceType44 = 44,
SurfaceType45 = 45,
SurfaceType46 = 46,
SurfaceType47 = 47,
SurfaceType48 = 48,
SurfaceType49 = 49,
SurfaceType50 = 50,
SurfaceType51 = 51,
SurfaceType52 = 52,
SurfaceType53 = 53,
SurfaceType54 = 54,
SurfaceType55 = 55,
SurfaceType56 = 56,
SurfaceType57 = 57,
SurfaceType58 = 58,
SurfaceType59 = 59,
SurfaceType60 = 60,
SurfaceType61 = 61,
SurfaceType62 = 62,
SurfaceType_Max = 63,
MAX = 64,
};
// Enum Engine.EUpdateRateShiftBucket
enum class EUpdateRateShiftBucket : uint8_t
{
ShiftBucket0 = 0,
ShiftBucket1 = 1,
ShiftBucket2 = 2,
ShiftBucket3 = 3,
ShiftBucket4 = 4,
ShiftBucket5 = 5,
ShiftBucketMax = 6,
MAX = 7,
};
// Enum Engine.EShadowMapFlags
enum class EShadowMapFlags : uint8_t
{
SMF_None = 0,
SMF_Streamed = 1,
SMF_MAX = 2,
};
// Enum Engine.ELightMapPaddingType
enum class ELightMapPaddingType : uint8_t
{
LMPT_NormalPadding = 0,
LMPT_PrePadding = 1,
LMPT_NoPadding = 2,
LMPT_MAX = 3,
};
// Enum Engine.ETimelineSigType
enum class ETimelineSigType : uint8_t
{
ETS_EventSignature = 0,
ETS_FloatSignature = 1,
ETS_VectorSignature = 2,
ETS_LinearColorSignature = 3,
ETS_InvalidSignature = 4,
ETS_MAX = 5,
};
// Enum Engine.EFilterInterpolationType
enum class EFilterInterpolationType : uint8_t
{
BSIT_Average = 0,
BSIT_Linear = 1,
BSIT_Cubic = 2,
BSIT_MAX = 3,
};
// Enum Engine.EOverlapFilterOption
enum class EOverlapFilterOption : uint8_t
{
OverlapFilter_All = 0,
OverlapFilter_DynamicOnly = 1,
OverlapFilter_StaticOnly = 2,
OverlapFilter_MAX = 3,
};
// Enum Engine.ENetworkSmoothingMode
enum class ENetworkSmoothingMode : uint8_t
{
Disabled = 0,
Linear = 1,
Exponential = 2,
Replay = 3,
MAX = 4,
};
// Enum Engine.ELightingBuildQuality
enum class ELightingBuildQuality : uint8_t
{
Quality_Preview = 0,
Quality_Medium = 1,
Quality_High = 2,
Quality_Production = 3,
Quality_MAX = 4,
};
// Enum Engine.EMaterialStencilCompare
enum class EMaterialStencilCompare : uint8_t
{
MSC_Less = 0,
MSC_LessEqual = 1,
MSC_Greater = 2,
MSC_GreaterEqual = 3,
MSC_Equal = 4,
MSC_NotEqual = 5,
MSC_Never = 6,
MSC_Always = 7,
MSC_Count = 8,
MSC_MAX = 9,
};
// Enum Engine.EMaterialSamplerType
enum class EMaterialSamplerType : uint8_t
{
SAMPLERTYPE_Color = 0,
SAMPLERTYPE_Grayscale = 1,
SAMPLERTYPE_Alpha = 2,
SAMPLERTYPE_Normal = 3,
SAMPLERTYPE_Masks = 4,
SAMPLERTYPE_DistanceFieldFont = 5,
SAMPLERTYPE_LinearColor = 6,
SAMPLERTYPE_LinearGrayscale = 7,
SAMPLERTYPE_Data = 8,
SAMPLERTYPE_External = 9,
SAMPLERTYPE_VirtualColor = 10,
SAMPLERTYPE_VirtualGrayscale = 11,
SAMPLERTYPE_VirtualAlpha = 12,
SAMPLERTYPE_VirtualNormal = 13,
SAMPLERTYPE_VirtualMasks = 14,
SAMPLERTYPE_VirtualLinearColor = 15,
SAMPLERTYPE_VirtualLinearGrayscale = 16,
SAMPLERTYPE_MAX = 17,
};
// Enum Engine.EMaterialTessellationMode
enum class EMaterialTessellationMode : uint8_t
{
MTM_NoTessellation = 0,
MTM_FlatTessellation = 1,
MTM_PNTriangles = 2,
MTM_MAX = 3,
};
// Enum Engine.EMaterialShadingModel
enum class EMaterialShadingModel : uint8_t
{
MSM_Unlit = 0,
MSM_DefaultLit = 1,
MSM_Subsurface = 2,
MSM_PreintegratedSkin = 3,
MSM_ClearCoat = 4,
MSM_SubsurfaceProfile = 5,
MSM_TwoSidedFoliage = 6,
MSM_Hair = 7,
MSM_Cloth = 8,
MSM_Eye = 9,
MSM_NUM = 10,
MSM_FromMaterialExpression = 11,
MSM_MAX = 12,
};
// Enum Engine.EParticleCollisionMode
enum class EParticleCollisionMode : uint8_t
{
SceneDepth = 0,
DistanceField = 1,
MAX = 2,
};
// Enum Engine.ETrailWidthMode
enum class ETrailWidthMode : uint8_t
{
FromCentre = 0,
FromFirst = 1,
FromSecond = 2,
MAX = 3,
};
// Enum Engine.EGBufferFormat
enum class EGBufferFormat : uint8_t
{
Force8BitsPerChannel = 0,
Default = 1,
HighPrecisionNormals = 2,
Force16BitsPerChannel = 3,
MAX = 4,
};
// Enum Engine.ESceneCaptureCompositeMode
enum class ESceneCaptureCompositeMode : uint8_t
{
SCCM_Overwrite = 0,
SCCM_Additive = 1,
SCCM_Composite = 2,
SCCM_MAX = 3,
};
// Enum Engine.ESceneCaptureSource
enum class ESceneCaptureSource : uint8_t
{
SCS_SceneColorHDR = 0,
SCS_SceneColorHDRNoAlpha = 1,
SCS_FinalColorLDR = 2,
SCS_SceneColorSceneDepth = 3,
SCS_SceneDepth = 4,
SCS_DeviceDepth = 5,
SCS_Normal = 6,
SCS_BaseColor = 7,
SCS_FinalColorHDR = 8,
SCS_MAX = 9,
};
// Enum Engine.ETranslucentSortPolicy
enum class ETranslucentSortPolicy : uint8_t
{
SortByDistance = 0,
SortByProjectedZ = 1,
SortAlongAxis = 2,
MAX = 3,
};
// Enum Engine.ERefractionMode
enum class ERefractionMode : uint8_t
{
RM_IndexOfRefraction = 0,
RM_PixelNormalOffset = 1,
RM_MAX = 2,
};
// Enum Engine.ETranslucencyLightingMode
enum class ETranslucencyLightingMode : uint8_t
{
TLM_VolumetricNonDirectional = 0,
TLM_VolumetricDirectional = 1,
TLM_VolumetricPerVertexNonDirectional = 2,
TLM_VolumetricPerVertexDirectional = 3,
TLM_Surface = 4,
TLM_SurfacePerPixelLighting = 5,
TLM_MAX = 6,
};
// Enum Engine.ESamplerSourceMode
enum class ESamplerSourceMode : uint8_t
{
SSM_FromTextureAsset = 0,
SSM_Wrap_WorldGroupSettings = 1,
SSM_Clamp_WorldGroupSettings = 2,
SSM_MAX = 3,
};
// Enum Engine.EOcclusionCombineMode
enum class EOcclusionCombineMode : uint8_t
{
OCM_Minimum = 0,
OCM_Multiply = 1,
OCM_MAX = 2,
};
// Enum Engine.EAspectRatioAxisConstraint
enum class EAspectRatioAxisConstraint : uint8_t
{
AspectRatio_MaintainYFOV = 0,
AspectRatio_MaintainXFOV = 1,
AspectRatio_MajorAxisFOV = 2,
AspectRatio_MAX = 3,
};
// Enum Engine.EFontCacheType
enum class EFontCacheType : uint8_t
{
Offline = 0,
Runtime = 1,
MAX = 2,
};
// Enum Engine.EFontImportCharacterSet
enum class EFontImportCharacterSet : uint8_t
{
FontICS_Default = 0,
FontICS_Ansi = 1,
FontICS_Symbol = 2,
FontICS_MAX = 3,
};
// Enum Engine.EStandbyType
enum class EStandbyType : uint8_t
{
STDBY_Rx = 0,
STDBY_Tx = 1,
STDBY_BadPing = 2,
STDBY_MAX = 3,
};
// Enum Engine.ESuggestProjVelocityTraceOption
enum class ESuggestProjVelocityTraceOption : uint8_t
{
DoNotTrace = 0,
TraceFullPath = 1,
OnlyTraceWhileAscending = 2,
MAX = 3,
};
// Enum Engine.EWindowMode
enum class EWindowMode : uint8_t
{
Fullscreen = 0,
WindowedFullscreen = 1,
Windowed = 2,
MAX = 3,
};
// Enum Engine.EImportanceWeight
enum class EImportanceWeight : uint8_t
{
Luminance = 0,
Red = 1,
Green = 2,
Blue = 3,
Alpha = 4,
MAX = 5,
};
// Enum Engine.EAdManagerDelegate
enum class EAdManagerDelegate : uint8_t
{
AMD_ClickedBanner = 0,
AMD_UserClosedAd = 1,
AMD_MAX = 2,
};
// Enum Engine.EControllerAnalogStick
enum class EControllerAnalogStick : uint8_t
{
CAS_LeftStick = 0,
CAS_RightStick = 1,
CAS_MAX = 2,
};
// Enum Engine.EAnimAlphaInputType
enum class EAnimAlphaInputType : uint8_t
{
Float = 0,
Bool = 1,
Curve = 2,
MAX = 3,
};
// Enum Engine.ETrackActiveCondition
enum class ETrackActiveCondition : uint8_t
{
ETAC_Always = 0,
ETAC_GoreEnabled = 1,
ETAC_GoreDisabled = 2,
ETAC_MAX = 3,
};
// Enum Engine.EInterpTrackMoveRotMode
enum class EInterpTrackMoveRotMode : uint8_t
{
IMR_Keyframed = 0,
IMR_LookAtGroup = 1,
IMR_Ignore = 2,
IMR_MAX = 3,
};
// Enum Engine.EInterpMoveAxis
enum class EInterpMoveAxis : uint8_t
{
AXIS_TranslationX = 0,
AXIS_TranslationY = 1,
AXIS_TranslationZ = 2,
AXIS_RotationX = 3,
AXIS_RotationY = 4,
AXIS_RotationZ = 5,
AXIS_MAX = 6,
};
// Enum Engine.ETrackToggleAction
enum class ETrackToggleAction : uint8_t
{
ETTA_Off = 0,
ETTA_On = 1,
ETTA_Toggle = 2,
ETTA_Trigger = 3,
ETTA_MAX = 4,
};
// Enum Engine.EVisibilityTrackCondition
enum class EVisibilityTrackCondition : uint8_t
{
EVTC_Always = 0,
EVTC_GoreEnabled = 1,
EVTC_GoreDisabled = 2,
EVTC_MAX = 3,
};
// Enum Engine.EVisibilityTrackAction
enum class EVisibilityTrackAction : uint8_t
{
EVTA_Hide = 0,
EVTA_Show = 1,
EVTA_Toggle = 2,
EVTA_MAX = 3,
};
// Enum Engine.ESlateGesture
enum class ESlateGesture : uint8_t
{
None = 0,
Scroll = 1,
Magnify = 2,
Swipe = 3,
Rotate = 4,
LongPress = 5,
MAX = 6,
};
// Enum Engine.ELerpInterpolationMode
enum class ELerpInterpolationMode : uint8_t
{
QuatInterp = 0,
EulerInterp = 1,
DualQuatInterp = 2,
MAX = 3,
};
// Enum Engine.EEasingFunc
enum class EEasingFunc : uint8_t
{
Linear = 0,
Step = 1,
SinusoidalIn = 2,
SinusoidalOut = 3,
SinusoidalInOut = 4,
EaseIn = 5,
EaseOut = 6,
EaseInOut = 7,
ExpoIn = 8,
ExpoOut = 9,
ExpoInOut = 10,
CircularIn = 11,
CircularOut = 12,
CircularInOut = 13,
MAX = 14,
};
// Enum Engine.ERoundingMode
enum class ERoundingMode : uint8_t
{
HalfToEven = 0,
HalfFromZero = 1,
HalfToZero = 2,
FromZero = 3,
ToZero = 4,
ToNegativeInfinity = 5,
ToPositiveInfinity = 6,
MAX = 7,
};
// Enum Engine.EStreamingVolumeUsage
enum class EStreamingVolumeUsage : uint8_t
{
SVB_Loading = 0,
SVB_LoadingAndVisibility = 1,
SVB_VisibilityBlockingOnLoad = 2,
SVB_BlockingOnLoad = 3,
SVB_LoadingNotVisible = 4,
SVB_MAX = 5,
};
// Enum Engine.EMaterialDecalResponse
enum class EMaterialDecalResponse : uint8_t
{
MDR_None = 0,
MDR_ColorNormalRoughness = 1,
MDR_Color = 2,
MDR_ColorNormal = 3,
MDR_ColorRoughness = 4,
MDR_Normal = 5,
MDR_NormalRoughness = 6,
MDR_Roughness = 7,
MDR_MAX = 8,
};
// Enum Engine.EDecalBlendMode
enum class EDecalBlendMode : uint8_t
{
DBM_Translucent = 0,
DBM_Stain = 1,
DBM_Normal = 2,
DBM_Emissive = 3,
DBM_DBuffer_ColorNormalRoughness = 4,
DBM_DBuffer_Color = 5,
DBM_DBuffer_ColorNormal = 6,
DBM_DBuffer_ColorRoughness = 7,
DBM_DBuffer_Normal = 8,
DBM_DBuffer_NormalRoughness = 9,
DBM_DBuffer_Roughness = 10,
DBM_DBuffer_Emissive = 11,
DBM_DBuffer_AlphaComposite = 12,
DBM_DBuffer_EmissiveAlphaComposite = 13,
DBM_Volumetric_DistanceFunction = 14,
DBM_AlphaComposite = 15,
DBM_AmbientOcclusion = 16,
DBM_MAX = 17,
};
// Enum Engine.ETextureColorChannel
enum class ETextureColorChannel : uint8_t
{
TCC_Red = 0,
TCC_Green = 1,
TCC_Blue = 2,
TCC_Alpha = 3,
TCC_MAX = 4,
};
// Enum Engine.EMaterialAttributeBlend
enum class EMaterialAttributeBlend : uint8_t
{
Blend = 0,
UseA = 1,
UseB = 2,
MAX = 3,
};
// Enum Engine.EChannelMaskParameterColor
enum class EChannelMaskParameterColor : uint8_t
{
Red = 0,
Green = 1,
Blue = 2,
Alpha = 3,
MAX = 4,
};
// Enum Engine.EClampMode
enum class EClampMode : uint8_t
{
CMODE_Clamp = 0,
CMODE_ClampMin = 1,
CMODE_ClampMax = 2,
CMODE_MAX = 3,
};
// Enum Engine.ECustomMaterialOutputType
enum class ECustomMaterialOutputType : uint8_t
{
CMOT_Float1 = 0,
CMOT_Float2 = 1,
CMOT_Float3 = 2,
CMOT_Float4 = 3,
CMOT_MAX = 4,
};
// Enum Engine.EDepthOfFieldFunctionValue
enum class EDepthOfFieldFunctionValue : uint8_t
{
TDOF_NearAndFarMask = 0,
TDOF_NearMask = 1,
TDOF_FarMask = 2,
TDOF_CircleOfConfusionRadius = 3,
TDOF_MAX = 4,
};
// Enum Engine.EFunctionInputType
enum class EFunctionInputType : uint8_t
{
FunctionInput_Scalar = 0,
FunctionInput_Vector2 = 1,
FunctionInput_Vector3 = 2,
FunctionInput_Vector4 = 3,
FunctionInput_Texture2D = 4,
FunctionInput_TextureCube = 5,
FunctionInput_VolumeTexture = 6,
FunctionInput_StaticBool = 7,
FunctionInput_MaterialAttributes = 8,
FunctionInput_TextureExternal = 9,
FunctionInput_MAX = 10,
};
// Enum Engine.ENoiseFunction
enum class ENoiseFunction : uint8_t
{
NOISEFUNCTION_SimplexTex = 0,
NOISEFUNCTION_GradientTex = 1,
NOISEFUNCTION_GradientTex3D = 2,
NOISEFUNCTION_GradientALU = 3,
NOISEFUNCTION_ValueALU = 4,
NOISEFUNCTION_VoronoiALU = 5,
NOISEFUNCTION_MAX = 6,
};
// Enum Engine.EMaterialSceneAttributeInputMode
enum class EMaterialSceneAttributeInputMode : uint8_t
{
Coordinates = 0,
OffsetFraction = 1,
MAX = 2,
};
// Enum Engine.ESpeedTreeLODType
enum class ESpeedTreeLODType : uint8_t
{
STLOD_Pop = 0,
STLOD_Smooth = 1,
STLOD_MAX = 2,
};
// Enum Engine.ESpeedTreeWindType
enum class ESpeedTreeWindType : uint8_t
{
STW_None = 0,
STW_Fastest = 1,
STW_Fast = 2,
STW_Better = 3,
STW_Best = 4,
STW_Palm = 5,
STW_BestPlus = 6,
STW_MAX = 7,
};
// Enum Engine.ESpeedTreeGeometryType
enum class ESpeedTreeGeometryType : uint8_t
{
STG_Branch = 0,
STG_Frond = 1,
STG_Leaf = 2,
STG_FacingLeaf = 3,
STG_Billboard = 4,
STG_MAX = 5,
};
// Enum Engine.EMaterialExposedTextureProperty
enum class EMaterialExposedTextureProperty : uint8_t
{
TMTM_TextureSize = 0,
TMTM_TexelSize = 1,
TMTM_MAX = 2,
};
// Enum Engine.ETextureMipValueMode
enum class ETextureMipValueMode : uint8_t
{
TMVM_None = 0,
TMVM_MipLevel = 1,
TMVM_MipBias = 2,
TMVM_Derivative = 3,
TMVM_MAX = 4,
};
// Enum Engine.EMaterialVectorCoordTransform
enum class EMaterialVectorCoordTransform : uint8_t
{
TRANSFORM_Tangent = 0,
TRANSFORM_Local = 1,
TRANSFORM_World = 2,
TRANSFORM_View = 3,
TRANSFORM_Camera = 4,
TRANSFORM_ParticleWorld = 5,
TRANSFORM_MAX = 6,
};
// Enum Engine.EMaterialVectorCoordTransformSource
enum class EMaterialVectorCoordTransformSource : uint8_t
{
TRANSFORMSOURCE_Tangent = 0,
TRANSFORMSOURCE_Local = 1,
TRANSFORMSOURCE_World = 2,
TRANSFORMSOURCE_View = 3,
TRANSFORMSOURCE_Camera = 4,
TRANSFORMSOURCE_ParticleWorld = 5,
TRANSFORMSOURCE_MAX = 6,
};
// Enum Engine.EMaterialPositionTransformSource
enum class EMaterialPositionTransformSource : uint8_t
{
TRANSFORMPOSSOURCE_Local = 0,
TRANSFORMPOSSOURCE_World = 1,
TRANSFORMPOSSOURCE_TranslatedWorld = 2,
TRANSFORMPOSSOURCE_View = 3,
TRANSFORMPOSSOURCE_Camera = 4,
TRANSFORMPOSSOURCE_Particle = 5,
TRANSFORMPOSSOURCE_MAX = 6,
};
// Enum Engine.EVectorNoiseFunction
enum class EVectorNoiseFunction : uint8_t
{
VNF_CellnoiseALU = 0,
VNF_VectorALU = 1,
VNF_GradientALU = 2,
VNF_CurlALU = 3,
VNF_VoronoiALU = 4,
VNF_MAX = 5,
};
// Enum Engine.EMaterialExposedViewProperty
enum class EMaterialExposedViewProperty : uint8_t
{
MEVP_BufferSize = 0,
MEVP_FieldOfView = 1,
MEVP_TanHalfFieldOfView = 2,
MEVP_ViewSize = 3,
MEVP_WorldSpaceViewPosition = 4,
MEVP_WorldSpaceCameraPosition = 5,
MEVP_ViewportOffset = 6,
MEVP_TemporalSampleCount = 7,
MEVP_TemporalSampleIndex = 8,
MEVP_TemporalSampleOffset = 9,
MEVP_RuntimeVirtualTextureOutputLevel = 10,
MEVP_RuntimeVirtualTextureOutputDerivative = 11,
MEVP_MAX = 12,
};
// Enum Engine.EWorldPositionIncludedOffsets
enum class EWorldPositionIncludedOffsets : uint8_t
{
WPT_Default = 0,
WPT_ExcludeAllShaderOffsets = 1,
WPT_CameraRelative = 2,
WPT_CameraRelativeNoOffsets = 3,
WPT_MAX = 4,
};
// Enum Engine.EMaterialFunctionUsage
enum class EMaterialFunctionUsage : uint8_t
{
Default = 0,
MaterialLayer = 1,
MaterialLayerBlend = 2,
MAX = 3,
};
// Enum Engine.EMaterialUsage
enum class EMaterialUsage : uint8_t
{
MATUSAGE_SkeletalMesh = 0,
MATUSAGE_ParticleSprites = 1,
MATUSAGE_BeamTrails = 2,
MATUSAGE_MeshParticles = 3,
MATUSAGE_StaticLighting = 4,
MATUSAGE_MorphTargets = 5,
MATUSAGE_SplineMesh = 6,
MATUSAGE_InstancedStaticMeshes = 7,
MATUSAGE_GeometryCollections = 8,
MATUSAGE_Clothing = 9,
MATUSAGE_NiagaraSprites = 10,
MATUSAGE_NiagaraRibbons = 11,
MATUSAGE_NiagaraMeshParticles = 12,
MATUSAGE_GeometryCache = 13,
MATUSAGE_MAX = 14,
};
// Enum Engine.EMaterialParameterAssociation
enum class EMaterialParameterAssociation : uint8_t
{
LayerParameter = 0,
BlendParameter = 1,
GlobalParameter = 2,
MAX = 3,
};
// Enum Engine.EMaterialMergeType
enum class EMaterialMergeType : uint8_t
{
MaterialMergeType_Default = 0,
MaterialMergeType_Simplygon = 1,
MaterialMergeType_MAX = 2,
};
// Enum Engine.ETextureSizingType
enum class ETextureSizingType : uint8_t
{
TextureSizingType_UseSingleTextureSize = 0,
TextureSizingType_UseAutomaticBiasedSizes = 1,
TextureSizingType_UseManualOverrideTextureSize = 2,
TextureSizingType_UseSimplygonAutomaticSizing = 3,
TextureSizingType_MAX = 4,
};
// Enum Engine.ESceneTextureId
enum class ESceneTextureId : uint8_t
{
PPI_SceneColor = 0,
PPI_SceneDepth = 1,
PPI_DiffuseColor = 2,
PPI_SpecularColor = 3,
PPI_SubsurfaceColor = 4,
PPI_BaseColor = 5,
PPI_Specular = 6,
PPI_Metallic = 7,
PPI_WorldNormal = 8,
PPI_SeparateTranslucency = 9,
PPI_Opacity = 10,
PPI_Roughness = 11,
PPI_MaterialAO = 12,
PPI_CustomDepth = 13,
PPI_PostProcessInput0 = 14,
PPI_PostProcessInput1 = 15,
PPI_PostProcessInput2 = 16,
PPI_PostProcessInput3 = 17,
PPI_PostProcessInput4 = 18,
PPI_PostProcessInput5 = 19,
PPI_PostProcessInput6 = 20,
PPI_DecalMask = 21,
PPI_ShadingModelColor = 22,
PPI_ShadingModelID = 23,
PPI_AmbientOcclusion = 24,
PPI_CustomStencil = 25,
PPI_StoredBaseColor = 26,
PPI_StoredSpecular = 27,
PPI_Velocity = 28,
PPI_MAX = 29,
};
// Enum Engine.EMaterialDomain
enum class EMaterialDomain : uint8_t
{
MD_Surface = 0,
MD_DeferredDecal = 1,
MD_LightFunction = 2,
MD_Volume = 3,
MD_PostProcess = 4,
MD_UI = 5,
MD_RuntimeVirtualTexture = 6,
MD_MAX = 7,
};
// Enum Engine.EMeshInstancingReplacementMethod
enum class EMeshInstancingReplacementMethod : uint8_t
{
RemoveOriginalActors = 0,
KeepOriginalActorsAsEditorOnly = 1,
MAX = 2,
};
// Enum Engine.EUVOutput
enum class EUVOutput : uint8_t
{
DoNotOutputChannel = 0,
OutputChannel = 1,
MAX = 2,
};
// Enum Engine.EMeshMergeType
enum class EMeshMergeType : uint8_t
{
MeshMergeType_Default = 0,
MeshMergeType_MergeActor = 1,
MeshMergeType_MAX = 2,
};
// Enum Engine.EMeshLODSelectionType
enum class EMeshLODSelectionType : uint8_t
{
AllLODs = 0,
SpecificLOD = 1,
CalculateLOD = 2,
LowestDetailLOD = 3,
MAX = 4,
};
// Enum Engine.EProxyNormalComputationMethod
enum class EProxyNormalComputationMethod : uint8_t
{
AngleWeighted = 0,
AreaWeighted = 1,
EqualWeighted = 2,
MAX = 3,
};
// Enum Engine.ELandscapeCullingPrecision
enum class ELandscapeCullingPrecision : uint8_t
{
High = 0,
Medium = 1,
Low = 2,
MAX = 3,
};
// Enum Engine.EStaticMeshReductionTerimationCriterion
enum class EStaticMeshReductionTerimationCriterion : uint8_t
{
Triangles = 0,
Vertices = 1,
Any = 2,
MAX = 3,
};
// Enum Engine.EMeshFeatureImportance
enum class EMeshFeatureImportance : uint8_t
{
Off = 0,
Lowest = 1,
Low = 2,
Normal = 3,
High = 4,
Highest = 5,
MAX = 6,
};
// Enum Engine.EVertexPaintAxis
enum class EVertexPaintAxis : uint8_t
{
X = 0,
Y = 1,
Z = 2,
MAX = 3,
};
// Enum Engine.EMicroTransactionResult
enum class EMicroTransactionResult : uint8_t
{
MTR_Succeeded = 0,
MTR_Failed = 1,
MTR_Canceled = 2,
MTR_RestoredFromServer = 3,
MTR_MAX = 4,
};
// Enum Engine.EMicroTransactionDelegate
enum class EMicroTransactionDelegate : uint8_t
{
MTD_PurchaseQueryComplete = 0,
MTD_PurchaseComplete = 1,
MTD_MAX = 2,
};
// Enum Engine.FNavigationSystemRunMode
enum class EFNavigationSystemRunMode : uint8_t
{
FNavigationSystemRunMode__InvalidMode = 0,
FNavigationSystemRunMode__GameMode = 1,
FNavigationSystemRunMode__EditorMode = 2,
FNavigationSystemRunMode__SimulationMode = 3,
FNavigationSystemRunMode__PIEMode = 4,
FNavigationSystemRunMode__FNavigationSystemRunMode_MAX = 5,
};
// Enum Engine.ENavigationQueryResult
enum class ENavigationQueryResult : uint8_t
{
Invalid = 0,
Error = 1,
Fail = 2,
Success = 3,
MAX = 4,
};
// Enum Engine.ENavPathEvent
enum class ENavPathEvent : uint8_t
{
Cleared = 0,
NewPath = 1,
UpdatedDueToGoalMoved = 2,
UpdatedDueToNavigationChanged = 3,
Invalidated = 4,
RePathFailed = 5,
MetaPathUpdate = 6,
Custom = 7,
MAX = 8,
};
// Enum Engine.ENavDataGatheringModeConfig
enum class ENavDataGatheringModeConfig : uint8_t
{
Invalid = 0,
Instant = 1,
Lazy = 2,
MAX = 3,
};
// Enum Engine.ENavDataGatheringMode
enum class ENavDataGatheringMode : uint8_t
{
Default = 0,
Instant = 1,
Lazy = 2,
MAX = 3,
};
// Enum Engine.ENavigationOptionFlag
enum class ENavigationOptionFlag : uint8_t
{
Default = 0,
Enable = 1,
Disable = 2,
MAX = 3,
};
// Enum Engine.ENavLinkDirection
enum class ENavLinkDirection : uint8_t
{
BothWays = 0,
LeftToRight = 1,
RightToLeft = 2,
MAX = 3,
};
// Enum Engine.EFastArraySerializerDeltaFlags
enum class EFastArraySerializerDeltaFlags : uint8_t
{
None = 0,
HasBeenSerialized = 1,
HasDeltaBeenRequested = 2,
IsUsingDeltaSerialization = 3,
MAX = 4,
};
// Enum Engine.EEmitterRenderMode
enum class EEmitterRenderMode : uint8_t
{
ERM_Normal = 0,
ERM_Point = 1,
ERM_Cross = 2,
ERM_LightsOnly = 3,
ERM_None = 4,
ERM_MAX = 5,
};
// Enum Engine.EParticleSubUVInterpMethod
enum class EParticleSubUVInterpMethod : uint8_t
{
PSUVIM_None = 0,
PSUVIM_Linear = 1,
PSUVIM_Linear_Blend = 2,
PSUVIM_Random = 3,
PSUVIM_Random_Blend = 4,
PSUVIM_MAX = 5,
};
// Enum Engine.EParticleBurstMethod
enum class EParticleBurstMethod : uint8_t
{
EPBM_Instant = 0,
EPBM_Interpolated = 1,
EPBM_MAX = 2,
};
// Enum Engine.EParticleSystemInsignificanceReaction
enum class EParticleSystemInsignificanceReaction : uint8_t
{
Auto = 0,
Complete = 1,
DisableTick = 2,
DisableTickAndKill = 3,
Num = 4,
MAX = 5,
};
// Enum Engine.EParticleSignificanceLevel
enum class EParticleSignificanceLevel : uint8_t
{
Low = 0,
Medium = 1,
High = 2,
Critical = 3,
Num = 4,
MAX = 5,
};
// Enum Engine.EParticleDetailMode
enum class EParticleDetailMode : uint8_t
{
PDM_Low = 0,
PDM_Medium = 1,
PDM_High = 2,
PDM_MAX = 3,
};
// Enum Engine.EParticleSourceSelectionMethod
enum class EParticleSourceSelectionMethod : uint8_t
{
EPSSM_Random = 0,
EPSSM_Sequential = 1,
EPSSM_MAX = 2,
};
// Enum Engine.EModuleType
enum class EModuleType : uint8_t
{
EPMT_General = 0,
EPMT_TypeData = 1,
EPMT_Beam = 2,
EPMT_Trail = 3,
EPMT_Spawn = 4,
EPMT_Required = 5,
EPMT_Event = 6,
EPMT_Light = 7,
EPMT_SubUV = 8,
EPMT_MAX = 9,
};
// Enum Engine.EAttractorParticleSelectionMethod
enum class EAttractorParticleSelectionMethod : uint8_t
{
EAPSM_Random = 0,
EAPSM_Sequential = 1,
EAPSM_MAX = 2,
};
// Enum Engine.Beam2SourceTargetTangentMethod
enum class EBeam2SourceTargetTangentMethod : uint8_t
{
PEB2STTM_Direct = 0,
PEB2STTM_UserSet = 1,
PEB2STTM_Distribution = 2,
PEB2STTM_Emitter = 3,
PEB2STTM_MAX = 4,
};
// Enum Engine.Beam2SourceTargetMethod
enum class EBeam2SourceTargetMethod : uint8_t
{
PEB2STM_Default = 0,
PEB2STM_UserSet = 1,
PEB2STM_Emitter = 2,
PEB2STM_Particle = 3,
PEB2STM_Actor = 4,
PEB2STM_MAX = 5,
};
// Enum Engine.BeamModifierType
enum class EBeamModifierType : uint8_t
{
PEB2MT_Source = 0,
PEB2MT_Target = 1,
PEB2MT_MAX = 2,
};
// Enum Engine.EParticleCameraOffsetUpdateMethod
enum class EParticleCameraOffsetUpdateMethod : uint8_t
{
EPCOUM_DirectSet = 0,
EPCOUM_Additive = 1,
EPCOUM_Scalar = 2,
EPCOUM_MAX = 3,
};
// Enum Engine.EParticleCollisionComplete
enum class EParticleCollisionComplete : uint8_t
{
EPCC_Kill = 0,
EPCC_Freeze = 1,
EPCC_HaltCollisions = 2,
EPCC_FreezeTranslation = 3,
EPCC_FreezeRotation = 4,
EPCC_FreezeMovement = 5,
EPCC_MAX = 6,
};
// Enum Engine.EParticleCollisionResponse
enum class EParticleCollisionResponse : uint8_t
{
Bounce = 0,
Stop = 1,
Kill = 2,
MAX = 3,
};
// Enum Engine.ELocationBoneSocketSelectionMethod
enum class ELocationBoneSocketSelectionMethod : uint8_t
{
BONESOCKETSEL_Sequential = 0,
BONESOCKETSEL_Random = 1,
BONESOCKETSEL_MAX = 2,
};
// Enum Engine.ELocationBoneSocketSource
enum class ELocationBoneSocketSource : uint8_t
{
BONESOCKETSOURCE_Bones = 0,
BONESOCKETSOURCE_Sockets = 1,
BONESOCKETSOURCE_MAX = 2,
};
// Enum Engine.ELocationEmitterSelectionMethod
enum class ELocationEmitterSelectionMethod : uint8_t
{
ELESM_Random = 0,
ELESM_Sequential = 1,
ELESM_MAX = 2,
};
// Enum Engine.CylinderHeightAxis
enum class ECylinderHeightAxis : uint8_t
{
PMLPC_HEIGHTAXIS_X = 0,
PMLPC_HEIGHTAXIS_Y = 1,
PMLPC_HEIGHTAXIS_Z = 2,
PMLPC_HEIGHTAXIS_MAX = 3,
};
// Enum Engine.ELocationSkelVertSurfaceSource
enum class ELocationSkelVertSurfaceSource : uint8_t
{
VERTSURFACESOURCE_Vert = 0,
VERTSURFACESOURCE_Surface = 1,
VERTSURFACESOURCE_MAX = 2,
};
// Enum Engine.EOrbitChainMode
enum class EOrbitChainMode : uint8_t
{
EOChainMode_Add = 0,
EOChainMode_Scale = 1,
EOChainMode_Link = 2,
EOChainMode_MAX = 3,
};
// Enum Engine.EParticleAxisLock
enum class EParticleAxisLock : uint8_t
{
EPAL_NONE = 0,
EPAL_X = 1,
EPAL_Y = 2,
EPAL_Z = 3,
EPAL_NEGATIVE_X = 4,
EPAL_NEGATIVE_Y = 5,
EPAL_NEGATIVE_Z = 6,
EPAL_ROTATE_X = 7,
EPAL_ROTATE_Y = 8,
EPAL_ROTATE_Z = 9,
EPAL_MAX = 10,
};
// Enum Engine.EEmitterDynamicParameterValue
enum class EEmitterDynamicParameterValue : uint8_t
{
EDPV_UserSet = 0,
EDPV_AutoSet = 1,
EDPV_VelocityX = 2,
EDPV_VelocityY = 3,
EDPV_VelocityZ = 4,
EDPV_VelocityMag = 5,
EDPV_MAX = 6,
};
// Enum Engine.EEmitterNormalsMode
enum class EEmitterNormalsMode : uint8_t
{
ENM_CameraFacing = 0,
ENM_Spherical = 1,
ENM_Cylindrical = 2,
ENM_MAX = 3,
};
// Enum Engine.EParticleSortMode
enum class EParticleSortMode : uint8_t
{
PSORTMODE_None = 0,
PSORTMODE_ViewProjDepth = 1,
PSORTMODE_DistanceToView = 2,
PSORTMODE_Age_OldestFirst = 3,
PSORTMODE_Age_NewestFirst = 4,
PSORTMODE_MAX = 5,
};
// Enum Engine.EParticleUVFlipMode
enum class EParticleUVFlipMode : uint8_t
{
None = 0,
FlipUV = 1,
FlipUOnly = 2,
FlipVOnly = 3,
RandomFlipUV = 4,
RandomFlipUOnly = 5,
RandomFlipVOnly = 6,
RandomFlipUVIndependent = 7,
MAX = 8,
};
// Enum Engine.ETrail2SourceMethod
enum class ETrail2SourceMethod : uint8_t
{
PET2SRCM_Default = 0,
PET2SRCM_Particle = 1,
PET2SRCM_Actor = 2,
PET2SRCM_MAX = 3,
};
// Enum Engine.EBeamTaperMethod
enum class EBeamTaperMethod : uint8_t
{
PEBTM_None = 0,
PEBTM_Full = 1,
PEBTM_Partial = 2,
PEBTM_MAX = 3,
};
// Enum Engine.EBeam2Method
enum class EBeam2Method : uint8_t
{
PEB2M_Distance = 0,
PEB2M_Target = 1,
PEB2M_Branch = 2,
PEB2M_MAX = 3,
};
// Enum Engine.EMeshCameraFacingOptions
enum class EMeshCameraFacingOptions : uint8_t
{
XAxisFacing_NoUp = 0,
XAxisFacing_ZUp = 1,
XAxisFacing_NegativeZUp = 2,
XAxisFacing_YUp = 3,
XAxisFacing_NegativeYUp = 4,
LockedAxis_ZAxisFacing = 5,
LockedAxis_NegativeZAxisFacing = 6,
LockedAxis_YAxisFacing = 7,
LockedAxis_NegativeYAxisFacing = 8,
VelocityAligned_ZAxisFacing = 9,
VelocityAligned_NegativeZAxisFacing = 10,
VelocityAligned_YAxisFacing = 11,
VelocityAligned_NegativeYAxisFacing = 12,
MAX = 13,
};
// Enum Engine.EMeshCameraFacingUpAxis
enum class EMeshCameraFacingUpAxis : uint8_t
{
CameraFacing_NoneUP = 0,
CameraFacing_ZUp = 1,
CameraFacing_NegativeZUp = 2,
CameraFacing_YUp = 3,
CameraFacing_NegativeYUp = 4,
CameraFacing_MAX = 5,
};
// Enum Engine.EMeshScreenAlignment
enum class EMeshScreenAlignment : uint8_t
{
PSMA_MeshFaceCameraWithRoll = 0,
PSMA_MeshFaceCameraWithSpin = 1,
PSMA_MeshFaceCameraWithLockedAxis = 2,
PSMA_MAX = 3,
};
// Enum Engine.ETrailsRenderAxisOption
enum class ETrailsRenderAxisOption : uint8_t
{
Trails_CameraUp = 0,
Trails_SourceUp = 1,
Trails_WorldUp = 2,
Trails_MAX = 3,
};
// Enum Engine.EParticleScreenAlignment
enum class EParticleScreenAlignment : uint8_t
{
PSA_FacingCameraPosition = 0,
PSA_Square = 1,
PSA_Rectangle = 2,
PSA_Velocity = 3,
PSA_AwayFromCenter = 4,
PSA_TypeSpecific = 5,
PSA_FacingCameraDistanceBlend = 6,
PSA_MAX = 7,
};
// Enum Engine.EParticleSystemOcclusionBoundsMethod
enum class EParticleSystemOcclusionBoundsMethod : uint8_t
{
EPSOBM_None = 0,
EPSOBM_ParticleBounds = 1,
EPSOBM_CustomBounds = 2,
EPSOBM_MAX = 3,
};
// Enum Engine.ParticleSystemLODMethod
enum class EParticleSystemLODMethod : uint8_t
{
PARTICLESYSTEMLODMETHOD_Automatic = 0,
PARTICLESYSTEMLODMETHOD_DirectSet = 1,
PARTICLESYSTEMLODMETHOD_ActivateAutomatic = 2,
PARTICLESYSTEMLODMETHOD_MAX = 3,
};
// Enum Engine.EParticleSystemUpdateMode
enum class EParticleSystemUpdateMode : uint8_t
{
EPSUM_RealTime = 0,
EPSUM_FixedTime = 1,
EPSUM_MAX = 2,
};
// Enum Engine.EParticleEventType
enum class EParticleEventType : uint8_t
{
EPET_Any = 0,
EPET_Spawn = 1,
EPET_Death = 2,
EPET_Collision = 3,
EPET_Burst = 4,
EPET_Blueprint = 5,
EPET_MAX = 6,
};
// Enum Engine.ParticleReplayState
enum class EParticleReplayState : uint8_t
{
PRS_Disabled = 0,
PRS_Capturing = 1,
PRS_Replaying = 2,
PRS_MAX = 3,
};
// Enum Engine.EParticleSysParamType
enum class EParticleSysParamType : uint8_t
{
PSPT_None = 0,
PSPT_Scalar = 1,
PSPT_ScalarRand = 2,
PSPT_Vector = 3,
PSPT_VectorRand = 4,
PSPT_Color = 5,
PSPT_Actor = 6,
PSPT_Material = 7,
PSPT_MAX = 8,
};
// Enum Engine.ESettingsLockedAxis
enum class ESettingsLockedAxis : uint8_t
{
None = 0,
X = 1,
Y = 2,
Z = 3,
Invalid = 4,
MAX = 5,
};
// Enum Engine.ESettingsDOF
enum class ESettingsDOF : uint8_t
{
Full3D = 0,
YZPlane = 1,
XZPlane = 2,
XYPlane = 3,
MAX = 4,
};
// Enum Engine.EFrictionCombineMode
enum class EFrictionCombineMode : uint8_t
{
Average = 0,
Min = 1,
Multiply = 2,
Max = 3,
};
// Enum Engine.EViewTargetBlendFunction
enum class EViewTargetBlendFunction : uint8_t
{
VTBlend_Linear = 0,
VTBlend_Cubic = 1,
VTBlend_EaseIn = 2,
VTBlend_EaseOut = 3,
VTBlend_EaseInOut = 4,
VTBlend_MAX = 5,
};
// Enum Engine.EDynamicForceFeedbackAction
enum class EDynamicForceFeedbackAction : uint8_t
{
Start = 0,
Update = 1,
Stop = 2,
MAX = 3,
};
// Enum Engine.ERichCurveExtrapolation
enum class ERichCurveExtrapolation : uint8_t
{
RCCE_Cycle = 0,
RCCE_CycleWithOffset = 1,
RCCE_Oscillate = 2,
RCCE_Linear = 3,
RCCE_Constant = 4,
RCCE_None = 5,
RCCE_MAX = 6,
};
// Enum Engine.ERichCurveInterpMode
enum class ERichCurveInterpMode : uint8_t
{
RCIM_Linear = 0,
RCIM_Constant = 1,
RCIM_Cubic = 2,
RCIM_None = 3,
RCIM_MAX = 4,
};
// Enum Engine.EReflectionSourceType
enum class EReflectionSourceType : uint8_t
{
CapturedScene = 0,
SpecifiedCubemap = 1,
MAX = 2,
};
// Enum Engine.EDefaultBackBufferPixelFormat
enum class EDefaultBackBufferPixelFormat : uint8_t
{
DBBPF_B8G8R8A8 = 0,
DBBPF_A16B16G16R16_DEPRECATED = 1,
DBBPF_FloatRGB_DEPRECATED = 2,
DBBPF_FloatRGBA = 3,
DBBPF_A2B10G10R10 = 4,
DBBPF_MAX = 5,
};
// Enum Engine.EAutoExposureMethodUI
enum class EAutoExposureMethodUI : uint8_t
{
AEM_Histogram = 0,
AEM_Basic = 1,
AEM_Manual = 2,
AEM_MAX = 3,
};
// Enum Engine.EAlphaChannelMode
enum class EAlphaChannelMode : uint8_t
{
Disabled = 0,
LinearColorSpaceOnly = 1,
AllowThroughTonemapper = 2,
MAX = 3,
};
// Enum Engine.EEarlyZPass
enum class EEarlyZPass : uint8_t
{
None = 0,
OpaqueOnly = 1,
OpaqueAndMasked = 2,
Auto = 3,
MAX = 4,
};
// Enum Engine.ECustomDepthStencil
enum class ECustomDepthStencil : uint8_t
{
Disabled = 0,
Enabled = 1,
EnabledOnDemand = 2,
EnabledWithStencil = 3,
MAX = 4,
};
// Enum Engine.EMobileMSAASampleCount
enum class EMobileMSAASampleCount : uint8_t
{
One = 0,
Two = 1,
Four = 2,
Eight = 3,
MAX = 4,
};
// Enum Engine.ECompositingSampleCount
enum class ECompositingSampleCount : uint8_t
{
One = 0,
Two = 1,
Four = 2,
Eight = 3,
MAX = 4,
};
// Enum Engine.EClearSceneOptions
enum class EClearSceneOptions : uint8_t
{
NoClear = 0,
HardwareClear = 1,
QuadAtMaxZ = 2,
MAX = 3,
};
// Enum Engine.EReporterLineStyle
enum class EReporterLineStyle : uint8_t
{
Line = 0,
Dash = 1,
MAX = 2,
};
// Enum Engine.ELegendPosition
enum class ELegendPosition : uint8_t
{
Outside = 0,
Inside = 1,
MAX = 2,
};
// Enum Engine.EGraphDataStyle
enum class EGraphDataStyle : uint8_t
{
Lines = 0,
Filled = 1,
MAX = 2,
};
// Enum Engine.EGraphAxisStyle
enum class EGraphAxisStyle : uint8_t
{
Lines = 0,
Notches = 1,
Grid = 2,
MAX = 3,
};
// Enum Engine.ERichCurveKeyTimeCompressionFormat
enum class ERichCurveKeyTimeCompressionFormat : uint8_t
{
RCKTCF_uint16 = 0,
RCKTCF_float32 = 1,
RCKTCF_MAX = 2,
};
// Enum Engine.ERichCurveCompressionFormat
enum class ERichCurveCompressionFormat : uint8_t
{
RCCF_Empty = 0,
RCCF_Constant = 1,
RCCF_Linear = 2,
RCCF_Cubic = 3,
RCCF_Mixed = 4,
RCCF_MAX = 5,
};
// Enum Engine.ERichCurveTangentWeightMode
enum class ERichCurveTangentWeightMode : uint8_t
{
RCTWM_WeightedNone = 0,
RCTWM_WeightedArrive = 1,
RCTWM_WeightedLeave = 2,
RCTWM_WeightedBoth = 3,
RCTWM_MAX = 4,
};
// Enum Engine.ERichCurveTangentMode
enum class ERichCurveTangentMode : uint8_t
{
RCTM_Auto = 0,
RCTM_User = 1,
RCTM_Break = 2,
RCTM_None = 3,
RCTM_MAX = 4,
};
// Enum Engine.EConstraintTransform
enum class EConstraintTransform : uint8_t
{
Absolute = 0,
Relative = 1,
MAX = 2,
};
// Enum Engine.EControlConstraint
enum class EControlConstraint : uint8_t
{
Orientation = 0,
Translation = 1,
MAX = 2,
};
// Enum Engine.ERootMotionFinishVelocityMode
enum class ERootMotionFinishVelocityMode : uint8_t
{
MaintainLastRootMotionVelocity = 0,
SetVelocity = 1,
ClampVelocity = 2,
MAX = 3,
};
// Enum Engine.ERootMotionSourceSettingsFlags
enum class ERootMotionSourceSettingsFlags : uint8_t
{
UseSensitiveLiftoffCheck = 0,
DisablePartialEndTick = 1,
MAX = 2,
};
// Enum Engine.ERootMotionSourceStatusFlags
enum class ERootMotionSourceStatusFlags : uint8_t
{
Prepared = 0,
Finished = 1,
MarkedForRemoval = 2,
MAX = 3,
};
// Enum Engine.ERootMotionAccumulateMode
enum class ERootMotionAccumulateMode : uint8_t
{
Override = 0,
Additive = 1,
MAX = 2,
};
// Enum Engine.ERuntimeVirtualTextureMaterialType
enum class ERuntimeVirtualTextureMaterialType : uint8_t
{
BaseColor = 0,
BaseColor_Normal = 1,
BaseColor_Normal_Specular = 2,
Count = 3,
MAX = 4,
};
// Enum Engine.ELightUnits
enum class ELightUnits : uint8_t
{
Unitless = 0,
Candelas = 1,
Lumens = 2,
MAX = 3,
};
// Enum Engine.EAntiAliasingMethod
enum class EAntiAliasingMethod : uint8_t
{
AAM_None = 0,
AAM_FXAA = 1,
AAM_TemporalAA = 2,
AAM_MSAA = 3,
AAM_MAX = 4,
};
// Enum Engine.EDepthOfFieldMethod
enum class EDepthOfFieldMethod : uint8_t
{
DOFM_BokehDOF = 0,
DOFM_Gaussian = 1,
DOFM_CircleDOF = 2,
DOFM_MAX = 3,
};
// Enum Engine.ESceneCapturePrimitiveRenderMode
enum class ESceneCapturePrimitiveRenderMode : uint8_t
{
PRM_LegacySceneCapture = 0,
PRM_RenderScenePrimitives = 1,
PRM_UseShowOnlyList = 2,
PRM_MAX = 3,
};
// Enum Engine.EMaterialProperty
enum class EMaterialProperty : uint8_t
{
MP_EmissiveColor = 0,
MP_Opacity = 1,
MP_OpacityMask = 2,
MP_DiffuseColor = 3,
MP_SpecularColor = 4,
MP_BaseColor = 5,
MP_Metallic = 6,
MP_Specular = 7,
MP_Roughness = 8,
MP_Normal = 9,
MP_WorldPositionOffset = 10,
MP_WorldDisplacement = 11,
MP_TessellationMultiplier = 12,
MP_SubsurfaceColor = 13,
MP_CustomData0 = 14,
MP_CustomData1 = 15,
MP_AmbientOcclusion = 16,
MP_Refraction = 17,
MP_CustomizedUVs0 = 18,
MP_CustomizedUVs1 = 19,
MP_CustomizedUVs2 = 20,
MP_CustomizedUVs3 = 21,
MP_CustomizedUVs4 = 22,
MP_CustomizedUVs5 = 23,
MP_CustomizedUVs6 = 24,
MP_CustomizedUVs7 = 25,
MP_PixelDepthOffset = 26,
MP_ShadingModel = 27,
MP_MaterialAttributes = 28,
MP_CustomOutput = 29,
MP_MAX = 30,
};
// Enum Engine.EPhysicsTransformUpdateMode
enum class EPhysicsTransformUpdateMode : uint8_t
{
SimulationUpatesComponentTransform = 0,
ComponentTransformIsKinematic = 1,
MAX = 2,
};
// Enum Engine.EAnimationMode
enum class EAnimationMode : uint8_t
{
AnimationBlueprint = 0,
AnimationSingleNode = 1,
AnimationCustomMode = 2,
MAX = 3,
};
// Enum Engine.EKinematicBonesUpdateToPhysics
enum class EKinematicBonesUpdateToPhysics : uint8_t
{
SkipSimulatingBones = 0,
SkipAllBones = 1,
MAX = 2,
};
// Enum Engine.EAnimCurveType
enum class EAnimCurveType : uint8_t
{
AttributeCurve = 0,
MaterialCurve = 1,
MorphTargetCurve = 2,
MaxAnimCurveType = 3,
MAX = 4,
};
// Enum Engine.EBoneFilterActionOption
enum class EBoneFilterActionOption : uint8_t
{
Remove = 0,
Keep = 1,
Invalid = 2,
MAX = 3,
};
// Enum Engine.SkeletalMeshOptimizationImportance
enum class ESkeletalMeshOptimizationImportance : uint8_t
{
SMOI_Off = 0,
SMOI_Lowest = 1,
SMOI_Low = 2,
SMOI_Normal = 3,
SMOI_High = 4,
SMOI_Highest = 5,
SMOI_MAX = 6,
};
// Enum Engine.SkeletalMeshOptimizationType
enum class ESkeletalMeshOptimizationType : uint8_t
{
SMOT_NumOfTriangles = 0,
SMOT_MaxDeviation = 1,
SMOT_TriangleOrDeviation = 2,
SMOT_MAX = 3,
};
// Enum Engine.SkeletalMeshTerminationCriterion
enum class ESkeletalMeshTerminationCriterion : uint8_t
{
SMTC_NumOfTriangles = 0,
SMTC_NumOfVerts = 1,
SMTC_TriangleOrVert = 2,
SMTC_AbsNumOfTriangles = 3,
SMTC_AbsNumOfVerts = 4,
SMTC_AbsTriangleOrVert = 5,
SMTC_MAX = 6,
};
// Enum Engine.EBoneTranslationRetargetingMode
enum class EBoneTranslationRetargetingMode : uint8_t
{
Animation = 0,
Skeleton = 1,
AnimationScaled = 2,
AnimationRelative = 3,
OrientAndScale = 4,
MAX = 5,
};
// Enum Engine.EBoneSpaces
enum class EBoneSpaces : uint8_t
{
WorldSpace = 0,
ComponentSpace = 1,
MAX = 2,
};
// Enum Engine.EVisibilityBasedAnimTickOption
enum class EVisibilityBasedAnimTickOption : uint8_t
{
AlwaysTickPoseAndRefreshBones = 0,
AlwaysTickPose = 1,
OnlyTickMontagesWhenNotRendered = 2,
OnlyTickPoseWhenRendered = 3,
MAX = 4,
};
// Enum Engine.EPhysBodyOp
enum class EPhysBodyOp : uint8_t
{
PBO_None = 0,
PBO_Term = 1,
PBO_MAX = 2,
};
// Enum Engine.EBoneVisibilityStatus
enum class EBoneVisibilityStatus : uint8_t
{
BVS_HiddenByParent = 0,
BVS_Visible = 1,
BVS_ExplicitlyHidden = 2,
BVS_MAX = 3,
};
// Enum Engine.ESkyLightSourceType
enum class ESkyLightSourceType : uint8_t
{
SLS_CapturedScene = 0,
SLS_SpecifiedCubemap = 1,
SLS_MAX = 2,
};
// Enum Engine.EReverbSendMethod
enum class EReverbSendMethod : uint8_t
{
Linear = 0,
CustomCurve = 1,
Manual = 2,
MAX = 3,
};
// Enum Engine.EAirAbsorptionMethod
enum class EAirAbsorptionMethod : uint8_t
{
Linear = 0,
CustomCurve = 1,
MAX = 2,
};
// Enum Engine.ESoundSpatializationAlgorithm
enum class ESoundSpatializationAlgorithm : uint8_t
{
SPATIALIZATION_Default = 0,
SPATIALIZATION_HRTF = 1,
SPATIALIZATION_MAX = 2,
};
// Enum Engine.ESoundDistanceCalc
enum class ESoundDistanceCalc : uint8_t
{
SOUNDDISTANCE_Normal = 0,
SOUNDDISTANCE_InfiniteXYPlane = 1,
SOUNDDISTANCE_InfiniteXZPlane = 2,
SOUNDDISTANCE_InfiniteYZPlane = 3,
SOUNDDISTANCE_MAX = 4,
};
// Enum Engine.EVirtualizationMode
enum class EVirtualizationMode : uint8_t
{
Disabled = 0,
PlayWhenSilent = 1,
Restart = 2,
MAX = 3,
};
// Enum Engine.EAudioOutputTarget
enum class EAudioOutputTarget : uint8_t
{
Speaker = 0,
Controller = 1,
ControllerFallbackToSpeaker = 2,
MAX = 3,
};
// Enum Engine.EMaxConcurrentResolutionRule
enum class EMaxConcurrentResolutionRule : uint8_t
{
PreventNew = 0,
StopOldest = 1,
StopFarthestThenPreventNew = 2,
StopFarthestThenOldest = 3,
StopLowestPriority = 4,
StopQuietest = 5,
StopLowestPriorityThenPreventNew = 6,
MAX = 7,
};
// Enum Engine.ESoundGroup
enum class ESoundGroup : uint8_t
{
SOUNDGROUP_Default = 0,
SOUNDGROUP_Effects = 1,
SOUNDGROUP_UI = 2,
SOUNDGROUP_Music = 3,
SOUNDGROUP_Voice = 4,
SOUNDGROUP_GameSoundGroup1 = 5,
SOUNDGROUP_GameSoundGroup2 = 6,
SOUNDGROUP_GameSoundGroup3 = 7,
SOUNDGROUP_GameSoundGroup4 = 8,
SOUNDGROUP_GameSoundGroup5 = 9,
SOUNDGROUP_GameSoundGroup6 = 10,
SOUNDGROUP_GameSoundGroup7 = 11,
SOUNDGROUP_GameSoundGroup8 = 12,
SOUNDGROUP_GameSoundGroup9 = 13,
SOUNDGROUP_GameSoundGroup10 = 14,
SOUNDGROUP_GameSoundGroup11 = 15,
SOUNDGROUP_GameSoundGroup12 = 16,
SOUNDGROUP_GameSoundGroup13 = 17,
SOUNDGROUP_GameSoundGroup14 = 18,
SOUNDGROUP_GameSoundGroup15 = 19,
SOUNDGROUP_GameSoundGroup16 = 20,
SOUNDGROUP_GameSoundGroup17 = 21,
SOUNDGROUP_GameSoundGroup18 = 22,
SOUNDGROUP_GameSoundGroup19 = 23,
SOUNDGROUP_GameSoundGroup20 = 24,
SOUNDGROUP_MAX = 25,
};
// Enum Engine.ModulationParamMode
enum class EModulationParamMode : uint8_t
{
MPM_Normal = 0,
MPM_Abs = 1,
MPM_Direct = 2,
MPM_MAX = 3,
};
// Enum Engine.ESourceBusChannels
enum class ESourceBusChannels : uint8_t
{
Mono = 0,
Stereo = 1,
MAX = 2,
};
// Enum Engine.ESourceBusSendLevelControlMethod
enum class ESourceBusSendLevelControlMethod : uint8_t
{
Linear = 0,
CustomCurve = 1,
Manual = 2,
MAX = 3,
};
// Enum Engine.ESendLevelControlMethod
enum class ESendLevelControlMethod : uint8_t
{
Linear = 0,
CustomCurve = 1,
Manual = 2,
MAX = 3,
};
// Enum Engine.EAudioRecordingExportType
enum class EAudioRecordingExportType : uint8_t
{
SoundWave = 0,
WavFile = 1,
MAX = 2,
};
// Enum Engine.ESubmixChannelFormat
enum class ESubmixChannelFormat : uint8_t
{
Device = 0,
Stereo = 1,
Quad = 2,
FiveDotOne = 3,
SevenDotOne = 4,
Ambisonics = 5,
Count = 6,
MAX = 7,
};
// Enum Engine.ESoundWaveFFTSize
enum class ESoundWaveFFTSize : uint8_t
{
VerySmall = 0,
Small = 1,
Medium = 2,
Large = 3,
VeryLarge = 4,
MAX = 5,
};
// Enum Engine.EDecompressionType
enum class EDecompressionType : uint8_t
{
DTYPE_Setup = 0,
DTYPE_Invalid = 1,
DTYPE_Preview = 2,
DTYPE_Native = 3,
DTYPE_RealTime = 4,
DTYPE_Procedural = 5,
DTYPE_Xenon = 6,
DTYPE_Streaming = 7,
DTYPE_MAX = 8,
};
// Enum Engine.ESplineCoordinateSpace
enum class ESplineCoordinateSpace : uint8_t
{
Local = 0,
World = 1,
MAX = 2,
};
// Enum Engine.ESplinePointType
enum class ESplinePointType : uint8_t
{
Linear = 0,
Curve = 1,
Constant = 2,
CurveClamped = 3,
CurveCustomTangent = 4,
MAX = 5,
};
// Enum Engine.ESplineMeshAxis
enum class ESplineMeshAxis : uint8_t
{
X = 0,
Y = 1,
Z = 2,
MAX = 3,
};
// Enum Engine.EOptimizationType
enum class EOptimizationType : uint8_t
{
OT_NumOfTriangles = 0,
OT_MaxDeviation = 1,
OT_MAX = 2,
};
// Enum Engine.EImportanceLevel
enum class EImportanceLevel : uint8_t
{
IL_Off = 0,
IL_Lowest = 1,
IL_Low = 2,
IL_Normal = 3,
IL_High = 4,
IL_Highest = 5,
TEMP_BROKEN2 = 6,
MAX = 7,
};
// Enum Engine.ENormalMode
enum class ENormalMode : uint8_t
{
NM_PreserveSmoothingGroups = 0,
NM_RecalculateNormals = 1,
NM_RecalculateNormalsSmooth = 2,
NM_RecalculateNormalsHard = 3,
TEMP_BROKEN = 4,
MAX = 5,
};
// Enum Engine.EStereoLayerShape
enum class EStereoLayerShape : uint8_t
{
SLSH_QuadLayer = 0,
SLSH_CylinderLayer = 1,
SLSH_CubemapLayer = 2,
SLSH_MAX = 3,
};
// Enum Engine.EStereoLayerType
enum class EStereoLayerType : uint8_t
{
SLT_WorldLocked = 0,
SLT_TrackerLocked = 1,
SLT_FaceLocked = 2,
SLT_MAX = 3,
};
// Enum Engine.EOpacitySourceMode
enum class EOpacitySourceMode : uint8_t
{
OSM_Alpha = 0,
OSM_ColorBrightness = 1,
OSM_RedChannel = 2,
OSM_GreenChannel = 3,
OSM_BlueChannel = 4,
OSM_MAX = 5,
};
// Enum Engine.ESubUVBoundingVertexCount
enum class ESubUVBoundingVertexCount : uint8_t
{
BVC_FourVertices = 0,
BVC_EightVertices = 1,
BVC_MAX = 2,
};
// Enum Engine.EVerticalTextAligment
enum class EVerticalTextAligment : uint8_t
{
EVRTA_TextTop = 0,
EVRTA_TextCenter = 1,
EVRTA_TextBottom = 2,
EVRTA_QuadTop = 3,
EVRTA_MAX = 4,
};
// Enum Engine.EHorizTextAligment
enum class EHorizTextAligment : uint8_t
{
EHTA_Left = 0,
EHTA_Center = 1,
EHTA_Right = 2,
EHTA_MAX = 3,
};
// Enum Engine.ETextureLossyCompressionAmount
enum class ETextureLossyCompressionAmount : uint8_t
{
TLCA_Default = 0,
TLCA_None = 1,
TLCA_Lowest = 2,
TLCA_Low = 3,
TLCA_Medium = 4,
TLCA_High = 5,
TLCA_Highest = 6,
TLCA_MAX = 7,
};
// Enum Engine.ETextureCompressionQuality
enum class ETextureCompressionQuality : uint8_t
{
TCQ_Default = 0,
TCQ_Lowest = 1,
TCQ_Low = 2,
TCQ_Medium = 3,
TCQ_High = 4,
TCQ_Highest = 5,
TCQ_MAX = 6,
};
// Enum Engine.ETextureSourceFormat
enum class ETextureSourceFormat : uint8_t
{
TSF_Invalid = 0,
TSF_G8 = 1,
TSF_BGRA8 = 2,
TSF_BGRE8 = 3,
TSF_RGBA16 = 4,
TSF_RGBA16F = 5,
TSF_RGBA8 = 6,
TSF_RGBE8 = 7,
TSF_MAX = 8,
};
// Enum Engine.ETextureSourceArtType
enum class ETextureSourceArtType : uint8_t
{
TSAT_Uncompressed = 0,
TSAT_PNGCompressed = 1,
TSAT_DDSFile = 2,
TSAT_MAX = 3,
};
// Enum Engine.ETextureMipCount
enum class ETextureMipCount : uint8_t
{
TMC_ResidentMips = 0,
TMC_AllMips = 1,
TMC_AllMipsBiased = 2,
TMC_MAX = 3,
};
// Enum Engine.ECompositeTextureMode
enum class ECompositeTextureMode : uint8_t
{
CTM_Disabled = 0,
CTM_NormalRoughnessToRed = 1,
CTM_NormalRoughnessToGreen = 2,
CTM_NormalRoughnessToBlue = 3,
CTM_NormalRoughnessToAlpha = 4,
CTM_MAX = 5,
};
// Enum Engine.TextureAddress
enum class ETextureAddress : uint8_t
{
TA_Wrap = 0,
TA_Clamp = 1,
TA_Mirror = 2,
TA_MAX = 3,
};
// Enum Engine.TextureFilter
enum class ETextureFilter : uint8_t
{
TF_Nearest = 0,
TF_Bilinear = 1,
TF_Trilinear = 2,
TF_Default = 3,
TF_MAX = 4,
};
// Enum Engine.TextureCompressionSettings
enum class ETextureCompressionSettings : uint8_t
{
TC_Default = 0,
TC_Normalmap = 1,
TC_Masks = 2,
TC_Grayscale = 3,
TC_Displacementmap = 4,
TC_VectorDisplacementmap = 5,
TC_HDR = 6,
TC_EditorIcon = 7,
TC_Alpha = 8,
TC_DistanceFieldFont = 9,
TC_HDR_Compressed = 10,
TC_BC7 = 11,
TC_MAX = 12,
};
// Enum Engine.ETextureMipLoadOptions
enum class ETextureMipLoadOptions : uint8_t
{
Default = 0,
AllMips = 1,
OnlyFirstMip = 2,
MAX = 3,
};
// Enum Engine.ETextureSamplerFilter
enum class ETextureSamplerFilter : uint8_t
{
Point = 0,
Bilinear = 1,
Trilinear = 2,
AnisotropicPoint = 3,
AnisotropicLinear = 4,
MAX = 5,
};
// Enum Engine.ETexturePowerOfTwoSetting
enum class ETexturePowerOfTwoSetting : uint8_t
{
None = 0,
PadToPowerOfTwo = 1,
PadToSquarePowerOfTwo = 2,
MAX = 3,
};
// Enum Engine.TextureMipGenSettings
enum class ETextureMipGenSettings : uint8_t
{
TMGS_FromTextureGroup = 0,
TMGS_SimpleAverage = 1,
TMGS_Sharpen0 = 2,
TMGS_Sharpen1 = 3,
TMGS_Sharpen2 = 4,
TMGS_Sharpen3 = 5,
TMGS_Sharpen4 = 6,
TMGS_Sharpen5 = 7,
TMGS_Sharpen6 = 8,
TMGS_Sharpen7 = 9,
TMGS_Sharpen8 = 10,
TMGS_Sharpen9 = 11,
TMGS_Sharpen10 = 12,
TMGS_NoMipmaps = 13,
TMGS_LeaveExistingMips = 14,
TMGS_Blur1 = 15,
TMGS_Blur2 = 16,
TMGS_Blur3 = 17,
TMGS_Blur4 = 18,
TMGS_Blur5 = 19,
TMGS_Unfiltered = 20,
TMGS_MAX = 21,
};
// Enum Engine.TextureGroup
enum class ETextureGroup : uint8_t
{
TEXTUREGROUP_World = 0,
TEXTUREGROUP_WorldNormalMap = 1,
TEXTUREGROUP_WorldSpecular = 2,
TEXTUREGROUP_Character = 3,
TEXTUREGROUP_CharacterNormalMap = 4,
TEXTUREGROUP_CharacterSpecular = 5,
TEXTUREGROUP_Weapon = 6,
TEXTUREGROUP_WeaponNormalMap = 7,
TEXTUREGROUP_WeaponSpecular = 8,
TEXTUREGROUP_Vehicle = 9,
TEXTUREGROUP_VehicleNormalMap = 10,
TEXTUREGROUP_VehicleSpecular = 11,
TEXTUREGROUP_Cinematic = 12,
TEXTUREGROUP_Effects = 13,
TEXTUREGROUP_EffectsNotFiltered = 14,
TEXTUREGROUP_Skybox = 15,
TEXTUREGROUP_UI = 16,
TEXTUREGROUP_Lightmap = 17,
TEXTUREGROUP_RenderTarget = 18,
TEXTUREGROUP_MobileFlattened = 19,
TEXTUREGROUP_ProcBuilding_Face = 20,
TEXTUREGROUP_ProcBuilding_LightMap = 21,
TEXTUREGROUP_Shadowmap = 22,
TEXTUREGROUP_ColorLookupTable = 23,
TEXTUREGROUP_Terrain_Heightmap = 24,
TEXTUREGROUP_Terrain_Weightmap = 25,
TEXTUREGROUP_Bokeh = 26,
TEXTUREGROUP_IESLightProfile = 27,
TEXTUREGROUP_Pixels2D = 28,
TEXTUREGROUP_HierarchicalLOD = 29,
TEXTUREGROUP_Impostor = 30,
TEXTUREGROUP_ImpostorNormalDepth = 31,
TEXTUREGROUP_8BitData = 32,
TEXTUREGROUP_16BitData = 33,
TEXTUREGROUP_Project01 = 34,
TEXTUREGROUP_Project02 = 35,
TEXTUREGROUP_Project03 = 36,
TEXTUREGROUP_Project04 = 37,
TEXTUREGROUP_Project05 = 38,
TEXTUREGROUP_Project06 = 39,
TEXTUREGROUP_Project07 = 40,
TEXTUREGROUP_Project08 = 41,
TEXTUREGROUP_Project09 = 42,
TEXTUREGROUP_Project10 = 43,
TEXTUREGROUP_MAX = 44,
};
// Enum Engine.ETextureRenderTargetFormat
enum class ETextureRenderTargetFormat : uint8_t
{
RTF_R8 = 0,
RTF_RG8 = 1,
RTF_RGBA8 = 2,
RTF_R16f = 3,
RTF_RG16f = 4,
RTF_RGBA16f = 5,
RTF_R32f = 6,
RTF_RG32f = 7,
RTF_RGBA32f = 8,
RTF_RGB10A2 = 9,
RTF_MAX = 10,
};
// Enum Engine.ETimecodeProviderSynchronizationState
enum class ETimecodeProviderSynchronizationState : uint8_t
{
Closed = 0,
Error = 1,
Synchronized = 2,
Synchronizing = 3,
MAX = 4,
};
// Enum Engine.ETimelineDirection
enum class ETimelineDirection : uint8_t
{
Forward = 0,
Backward = 1,
MAX = 2,
};
// Enum Engine.ETimelineLengthMode
enum class ETimelineLengthMode : uint8_t
{
TL_TimelineLength = 0,
TL_LastKeyFrame = 1,
TL_MAX = 2,
};
// Enum Engine.ETimeStretchCurveMapping
enum class ETimeStretchCurveMapping : uint8_t
{
T_Original = 0,
T_TargetMin = 1,
T_TargetMax = 2,
MAX = 3,
};
// Enum Engine.ETwitterIntegrationDelegate
enum class ETwitterIntegrationDelegate : uint8_t
{
TID_AuthorizeComplete = 0,
TID_TweetUIComplete = 1,
TID_RequestComplete = 2,
TID_MAX = 3,
};
// Enum Engine.ETwitterRequestMethod
enum class ETwitterRequestMethod : uint8_t
{
TRM_Get = 0,
TRM_Post = 1,
TRM_Delete = 2,
TRM_MAX = 3,
};
// Enum Engine.EUserDefinedStructureStatus
enum class EUserDefinedStructureStatus : uint8_t
{
UDSS_UpToDate = 0,
UDSS_Dirty = 1,
UDSS_Error = 2,
UDSS_Duplicate = 3,
UDSS_MAX = 4,
};
// Enum Engine.EUIScalingRule
enum class EUIScalingRule : uint8_t
{
ShortestSide = 0,
LongestSide = 1,
Horizontal = 2,
Vertical = 3,
Custom = 4,
MAX = 5,
};
// Enum Engine.ERenderFocusRule
enum class ERenderFocusRule : uint8_t
{
Always = 0,
NonPointer = 1,
NavigationOnly = 2,
Never = 3,
MAX = 4,
};
// Enum Engine.EVectorFieldConstructionOp
enum class EVectorFieldConstructionOp : uint8_t
{
VFCO_Extrude = 0,
VFCO_Revolve = 1,
VFCO_MAX = 2,
};
// Enum Engine.EWindSourceType
enum class EWindSourceType : uint8_t
{
Directional = 0,
Point = 1,
MAX = 2,
};
// Enum Engine.EPSCPoolMethod
enum class EPSCPoolMethod : uint8_t
{
None = 0,
AutoRelease = 1,
ManualRelease = 2,
ManualRelease_OnComplete = 3,
FreeInPool = 4,
MAX = 5,
};
// Enum Engine.EVolumeLightingMethod
enum class EVolumeLightingMethod : uint8_t
{
VLM_VolumetricLightmap = 0,
VLM_SparseVolumeLightingSamples = 1,
VLM_MAX = 2,
};
// Enum Engine.EVisibilityAggressiveness
enum class EVisibilityAggressiveness : uint8_t
{
VIS_LeastAggressive = 0,
VIS_ModeratelyAggressive = 1,
VIS_MostAggressive = 2,
VIS_Max = 3,
};
// Enum Engine.ETextGender
enum class ETextGender : uint8_t
{
Masculine = 0,
Feminine = 1,
Neuter = 2,
MAX = 3,
};
// Enum Engine.EFormatArgumentType
enum class EFormatArgumentType : uint8_t
{
Int = 0,
UInt = 1,
Float = 2,
Double = 3,
Text = 4,
Gender = 5,
MAX = 6,
};
// Enum Engine.EEndPlayReason
enum class EEndPlayReason : uint8_t
{
Destroyed = 0,
LevelTransition = 1,
EndPlayInEditor = 2,
RemovedFromWorld = 3,
Quit = 4,
MAX = 5,
};
// Enum Engine.ETickingGroup
enum class ETickingGroup : uint8_t
{
TG_PrePhysics = 0,
TG_StartPhysics = 1,
TG_DuringPhysics = 2,
TG_EndPhysics = 3,
TG_PostPhysics = 4,
TG_PostUpdateWork = 5,
TG_LastDemotable = 6,
TG_NewlySpawned = 7,
TG_MAX = 8,
};
// Enum Engine.EComponentCreationMethod
enum class EComponentCreationMethod : uint8_t
{
Native = 0,
SimpleConstructionScript = 1,
UserConstructionScript = 2,
Instance = 3,
MAX = 4,
};
// Enum Engine.ETemperatureSeverityType
enum class ETemperatureSeverityType : uint8_t
{
Unknown = 0,
Good = 1,
Bad = 2,
Serious = 3,
Critical = 4,
NumSeverities = 5,
MAX = 6,
};
// Enum Engine.EPlaneConstraintAxisSetting
enum class EPlaneConstraintAxisSetting : uint8_t
{
Custom = 0,
X = 1,
Y = 2,
Z = 3,
UseGlobalPhysicsSetting = 4,
MAX = 5,
};
// Enum Engine.EInterpToBehaviourType
enum class EInterpToBehaviourType : uint8_t
{
OneShot = 0,
OneShot_Reverse = 1,
Loop_Reset = 2,
PingPong = 3,
MAX = 4,
};
// Enum Engine.ETeleportType
enum class ETeleportType : uint8_t
{
None = 0,
TeleportPhysics = 1,
ResetPhysics = 2,
MAX = 3,
};
// Enum Engine.EPlatformInterfaceDataType
enum class EPlatformInterfaceDataType : uint8_t
{
PIDT_None = 0,
PIDT_Int = 1,
PIDT_Float = 2,
PIDT_String = 3,
PIDT_Object = 4,
PIDT_Custom = 5,
PIDT_MAX = 6,
};
// Enum Engine.EMovementMode
enum class EMovementMode : uint8_t
{
MOVE_None = 0,
MOVE_Walking = 1,
MOVE_NavWalking = 2,
MOVE_Falling = 3,
MOVE_Swimming = 4,
MOVE_Flying = 5,
MOVE_Custom = 6,
MOVE_MAX = 7,
};
// Enum Engine.ENetworkFailure
enum class ENetworkFailure : uint8_t
{
NetDriverAlreadyExists = 0,
NetDriverCreateFailure = 1,
NetDriverListenFailure = 2,
ConnectionLost = 3,
ConnectionTimeout = 4,
FailureReceived = 5,
OutdatedClient = 6,
OutdatedServer = 7,
PendingConnectionFailure = 8,
NetGuidMismatch = 9,
NetChecksumMismatch = 10,
MAX = 11,
};
// Enum Engine.ETravelFailure
enum class ETravelFailure : uint8_t
{
NoLevel = 0,
LoadMapFailure = 1,
InvalidURL = 2,
PackageMissing = 3,
PackageVersion = 4,
NoDownload = 5,
TravelFailure = 6,
CheatCommands = 7,
PendingNetGameCreateFailure = 8,
CloudSaveFailure = 9,
ServerTravelFailure = 10,
ClientTravelFailure = 11,
MAX = 12,
};
// Enum Engine.EScreenOrientation
enum class EScreenOrientation : uint8_t
{
Unknown = 0,
Portrait = 1,
PortraitUpsideDown = 2,
LandscapeLeft = 3,
LandscapeRight = 4,
FaceUp = 5,
FaceDown = 6,
MAX = 7,
};
// Enum Engine.EApplicationState
enum class EApplicationState : uint8_t
{
Unknown = 0,
Inactive = 1,
Background = 2,
Active = 3,
MAX = 4,
};
// Enum Engine.EObjectTypeQuery
enum class EObjectTypeQuery : uint8_t
{
ObjectTypeQuery1 = 0,
ObjectTypeQuery2 = 1,
ObjectTypeQuery3 = 2,
ObjectTypeQuery4 = 3,
ObjectTypeQuery5 = 4,
ObjectTypeQuery6 = 5,
ObjectTypeQuery7 = 6,
ObjectTypeQuery8 = 7,
ObjectTypeQuery9 = 8,
ObjectTypeQuery10 = 9,
ObjectTypeQuery11 = 10,
ObjectTypeQuery12 = 11,
ObjectTypeQuery13 = 12,
ObjectTypeQuery14 = 13,
ObjectTypeQuery15 = 14,
ObjectTypeQuery16 = 15,
ObjectTypeQuery17 = 16,
ObjectTypeQuery18 = 17,
ObjectTypeQuery19 = 18,
ObjectTypeQuery20 = 19,
ObjectTypeQuery21 = 20,
ObjectTypeQuery22 = 21,
ObjectTypeQuery23 = 22,
ObjectTypeQuery24 = 23,
ObjectTypeQuery25 = 24,
ObjectTypeQuery26 = 25,
ObjectTypeQuery27 = 26,
ObjectTypeQuery28 = 27,
ObjectTypeQuery29 = 28,
ObjectTypeQuery30 = 29,
ObjectTypeQuery31 = 30,
ObjectTypeQuery32 = 31,
ObjectTypeQuery_MAX = 32,
MAX = 33,
};
// Enum Engine.EDrawDebugTrace
enum class EDrawDebugTrace : uint8_t
{
None = 0,
ForOneFrame = 1,
ForDuration = 2,
Persistent = 3,
MAX = 4,
};
// Enum Engine.ETraceTypeQuery
enum class ETraceTypeQuery : uint8_t
{
TraceTypeQuery1 = 0,
TraceTypeQuery2 = 1,
TraceTypeQuery3 = 2,
TraceTypeQuery4 = 3,
TraceTypeQuery5 = 4,
TraceTypeQuery6 = 5,
TraceTypeQuery7 = 6,
TraceTypeQuery8 = 7,
TraceTypeQuery9 = 8,
TraceTypeQuery10 = 9,
TraceTypeQuery11 = 10,
TraceTypeQuery12 = 11,
TraceTypeQuery13 = 12,
TraceTypeQuery14 = 13,
TraceTypeQuery15 = 14,
TraceTypeQuery16 = 15,
TraceTypeQuery17 = 16,
TraceTypeQuery18 = 17,
TraceTypeQuery19 = 18,
TraceTypeQuery20 = 19,
TraceTypeQuery21 = 20,
TraceTypeQuery22 = 21,
TraceTypeQuery23 = 22,
TraceTypeQuery24 = 23,
TraceTypeQuery25 = 24,
TraceTypeQuery26 = 25,
TraceTypeQuery27 = 26,
TraceTypeQuery28 = 27,
TraceTypeQuery29 = 28,
TraceTypeQuery30 = 29,
TraceTypeQuery31 = 30,
TraceTypeQuery32 = 31,
TraceTypeQuery_MAX = 32,
MAX = 33,
};
// Enum Engine.EMoveComponentAction
enum class EMoveComponentAction : uint8_t
{
Move = 0,
Stop = 1,
Return = 2,
MAX = 3,
};
// Enum Engine.EQuitPreference
enum class EQuitPreference : uint8_t
{
Quit = 0,
Background = 1,
MAX = 2,
};
// Enum Engine.ENetRole
enum class ENetRole : uint8_t
{
ROLE_None = 0,
ROLE_SimulatedProxy = 1,
ROLE_AutonomousProxy = 2,
ROLE_Authority = 3,
ROLE_MAX = 4,
};
// Enum Engine.EAttachLocation
enum class EAttachLocation : uint8_t
{
KeepRelativeOffset = 0,
KeepWorldPosition = 1,
SnapToTarget = 2,
SnapToTargetIncludingScale = 3,
MAX = 4,
};
// Enum Engine.EAttachmentRule
enum class EAttachmentRule : uint8_t
{
KeepRelative = 0,
KeepWorld = 1,
SnapToTarget = 2,
MAX = 3,
};
// Enum Engine.EDetachmentRule
enum class EDetachmentRule : uint8_t
{
KeepRelative = 0,
KeepWorld = 1,
MAX = 2,
};
// Enum Engine.ENetDormancy
enum class ENetDormancy : uint8_t
{
DORM_Never = 0,
DORM_Awake = 1,
DORM_DormantAll = 2,
DORM_DormantPartial = 3,
DORM_Initial = 4,
DORM_MAX = 5,
};
// Enum Engine.EAutoReceiveInput
enum class EAutoReceiveInput : uint8_t
{
Disabled = 0,
Player0 = 1,
Player1 = 2,
Player2 = 3,
Player3 = 4,
Player4 = 5,
Player5 = 6,
Player6 = 7,
Player7 = 8,
MAX = 9,
};
// Enum Engine.ESpawnActorCollisionHandlingMethod
enum class ESpawnActorCollisionHandlingMethod : uint8_t
{
Undefined = 0,
AlwaysSpawn = 1,
AdjustIfPossibleButAlwaysSpawn = 2,
AdjustIfPossibleButDontSpawnIfColliding = 3,
DontSpawnIfColliding = 4,
MAX = 5,
};
// Enum Engine.ERotatorQuantization
enum class ERotatorQuantization : uint8_t
{
ByteComponents = 0,
ShortComponents = 1,
MAX = 2,
};
// Enum Engine.EVectorQuantization
enum class EVectorQuantization : uint8_t
{
RoundWholeNumber = 0,
RoundOneDecimal = 1,
RoundTwoDecimals = 2,
MAX = 3,
};
// Enum Engine.EAutoPossessAI
enum class EAutoPossessAI : uint8_t
{
Disabled = 0,
PlacedInWorld = 1,
Spawned = 2,
PlacedInWorldOrSpawned = 3,
MAX = 4,
};
// Enum Engine.EReflectedAndRefractedRayTracedShadows
enum class EReflectedAndRefractedRayTracedShadows : uint8_t
{
Disabled = 0,
Hard_shadows = 1,
Area_shadows = 2,
MAX = 3,
};
//---------------------------------------------------------------------------
// Script Structs
//---------------------------------------------------------------------------
// ScriptStruct Engine.BeamTargetData
// 0x000C
struct FBeamTargetData
{
struct FName TargetName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TargetPercentage; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.GPUSpriteResourceData
// 0x0160
struct FGPUSpriteResourceData
{
TArray<struct FColor> QuantizedColorSamples; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FColor> QuantizedMiscSamples; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FColor> QuantizedSimulationAttrSamples; // 0x0020(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
struct FVector4 ColorScale; // 0x0030(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorBias; // 0x0040(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 MiscScale; // 0x0050(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 MiscBias; // 0x0060(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 SimulationAttrCurveScale; // 0x0070(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 SimulationAttrCurveBias; // 0x0080(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 SubImageSize; // 0x0090(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 SizeBySpeed; // 0x00A0(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector ConstantAcceleration; // 0x00B0(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector OrbitOffsetBase; // 0x00BC(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector OrbitOffsetRange; // 0x00C8(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector OrbitFrequencyBase; // 0x00D4(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector OrbitFrequencyRange; // 0x00E0(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector OrbitPhaseBase; // 0x00EC(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector OrbitPhaseRange; // 0x00F8(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float GlobalVectorFieldScale; // 0x0104(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float GlobalVectorFieldTightness; // 0x0108(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PerParticleVectorFieldScale; // 0x010C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PerParticleVectorFieldBias; // 0x0110(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DragCoefficientScale; // 0x0114(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DragCoefficientBias; // 0x0118(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ResilienceScale; // 0x011C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ResilienceBias; // 0x0120(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CollisionRadiusScale; // 0x0124(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CollisionRadiusBias; // 0x0128(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CollisionTimeBias; // 0x012C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CollisionRandomSpread; // 0x0130(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CollisionRandomDistribution; // 0x0134(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OneMinusFriction; // 0x0138(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float RotationRateScale; // 0x013C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CameraMotionBlurAmount; // 0x0140(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EParticleScreenAlignment> ScreenAlignment; // 0x0144(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EParticleAxisLock> LockAxisFlag; // 0x0145(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_CGR6[0x2]; // 0x0146(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FVector2D PivotOffset; // 0x0148(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRemoveHMDRoll : 1; // 0x0150(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VPW8[0x3]; // 0x0151(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float MinFacingCameraBlendDistance; // 0x0154(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxFacingCameraBlendDistance; // 0x0158(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_9634[0x4]; // 0x015C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.GPUSpriteLocalVectorFieldInfo
// 0x0070
struct FGPUSpriteLocalVectorFieldInfo
{
class UVectorField* Field; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_A0OV[0x8]; // 0x0008(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FTransform Transform; // 0x0010(0x0030) (IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FRotator MinInitialRotation; // 0x0040(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FRotator MaxInitialRotation; // 0x004C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FRotator RotationRate; // 0x0058(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
float Intensity; // 0x0064(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Tightness; // 0x0068(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIgnoreComponentTransform : 1; // 0x006C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bTileX : 1; // 0x006C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bTileY : 1; // 0x006C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bTileZ : 1; // 0x006C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseFixDT : 1; // 0x006C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EJTM[0x3]; // 0x006D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.DistributionLookupTable
// 0x0028
struct FDistributionLookupTable
{
unsigned char Op; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char EntryCount; // 0x0001(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char EntryStride; // 0x0002(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char SubEntryStride; // 0x0003(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TimeScale; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TimeBias; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_SSBB[0x4]; // 0x000C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<float> Values; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char LockFlag; // 0x0020(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_40ZR[0x7]; // 0x0021(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.FloatDistribution
// 0x0028
struct FFloatDistribution
{
struct FDistributionLookupTable table; // 0x0000(0x0028) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TickFunction
// 0x0050
struct FTickFunction
{
unsigned char UnknownData_3OYW[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<ETickingGroup> TickGroup; // 0x0008(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ETickingGroup> EndTickGroup; // 0x0009(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_P22X[0x2]; // 0x000A(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bTickEvenWhenPaused : 1; // 0x000C(0x0001) BIT_FIELD (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCanEverTick : 1; // 0x000C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bStartWithTickEnabled : 1; // 0x000C(0x0001) BIT_FIELD (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAllowTickOnDedicatedServer : 1; // 0x000C(0x0001) BIT_FIELD (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_A0P0[0x33]; // 0x000D(0x0033) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float TickInterval; // 0x0040(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_AA6W[0xC]; // 0x0044(0x000C) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.RawDistribution
// 0x0028
struct FRawDistribution
{
struct FDistributionLookupTable table; // 0x0000(0x0028) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RawDistributionVector
// 0x0028 (0x0050 - 0x0028)
struct FRawDistributionVector : public FRawDistribution
{
float MinValue; // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
float MaxValue; // 0x002C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
struct FVector MinValueVec; // 0x0030(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
struct FVector MaxValueVec; // 0x003C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UDistributionVector* Distribution; // 0x0048(0x0008) (Edit, ExportObject, ZeroConstructor, InstancedReference, NoClear, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ActorTickFunction
// 0x0008 (0x0058 - 0x0050)
struct FActorTickFunction : public FTickFunction
{
unsigned char UnknownData_QI03[0x8]; // 0x0050(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.RawDistributionFloat
// 0x0010 (0x0038 - 0x0028)
struct FRawDistributionFloat : public FRawDistribution
{
float MinValue; // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
float MaxValue; // 0x002C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UDistributionFloat* Distribution; // 0x0030(0x0008) (Edit, ExportObject, ZeroConstructor, InstancedReference, NoClear, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.GPUSpriteEmitterInfo
// 0x02C0
struct FGPUSpriteEmitterInfo
{
class UParticleModuleRequired* RequiredModule; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UParticleModuleSpawn* SpawnModule; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UParticleModuleSpawnPerUnit* SpawnPerUnitModule; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<class UParticleModule*> SpawnModules; // 0x0018(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_XFZ8[0x8]; // 0x0028(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FGPUSpriteLocalVectorFieldInfo LocalVectorField; // 0x0030(0x0070) (NoDestructor, NativeAccessSpecifierPublic)
struct FFloatDistribution VectorFieldScale; // 0x00A0(0x0028) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FFloatDistribution DragCoefficient; // 0x00C8(0x0028) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FFloatDistribution PointAttractorStrength; // 0x00F0(0x0028) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FFloatDistribution Resilience; // 0x0118(0x0028) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector ConstantAcceleration; // 0x0140(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector PointAttractorPosition; // 0x014C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PointAttractorRadiusSq; // 0x0158(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector OrbitOffsetBase; // 0x015C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector OrbitOffsetRange; // 0x0168(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D InvMaxSize; // 0x0174(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float InvRotationRateScale; // 0x017C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxLifetime; // 0x0180(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MaxParticleCount; // 0x0184(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EParticleScreenAlignment> ScreenAlignment; // 0x0188(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EParticleAxisLock> LockAxisFlag; // 0x0189(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_1TPQ[0x2]; // 0x018A(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bEnableCollision : 1; // 0x018C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_4296[0x3]; // 0x018D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<EParticleCollisionMode> CollisionMode; // 0x0190(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_DUPW[0x3]; // 0x0191(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bRemoveHMDRoll : 1; // 0x0194(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_C2GM[0x3]; // 0x0195(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float MinFacingCameraBlendDistance; // 0x0198(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxFacingCameraBlendDistance; // 0x019C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRawDistributionVector DynamicColor; // 0x01A0(0x0050) (ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FRawDistributionFloat DynamicAlpha; // 0x01F0(0x0038) (ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FRawDistributionVector DynamicColorScale; // 0x0228(0x0050) (ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FRawDistributionFloat DynamicAlphaScale; // 0x0278(0x0038) (ContainsInstancedReference, NativeAccessSpecifierPublic)
unsigned char UnknownData_R6LP[0x10]; // 0x02B0(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.NamedEmitterMaterial
// 0x0010
struct FNamedEmitterMaterial
{
struct FName Name; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UMaterialInterface* Material; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LODSoloTrack
// 0x0010
struct FLODSoloTrack
{
TArray<unsigned char> SoloEnableSetting; // 0x0000(0x0010) (ZeroConstructor, Transient, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.DebugTextInfo
// 0x0060
struct FDebugTextInfo
{
class AActor* SrcActor; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector SrcActorOffset; // 0x0008(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector SrcActorDesiredOffset; // 0x0014(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString DebugText; // 0x0020(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TimeRemaining; // 0x0030(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Duration; // 0x0034(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FColor TextColor; // 0x0038(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAbsoluteLocation : 1; // 0x003C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bKeepAttachedToActor : 1; // 0x003C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bDrawShadow : 1; // 0x003C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_G8CR[0x3]; // 0x003D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FVector OrigActorLocation; // 0x0040(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_WPUW[0x4]; // 0x004C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UFont* Font; // 0x0050(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FontScale; // 0x0058(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_964Y[0x4]; // 0x005C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ParticleSystemLOD
// 0x0001
struct FParticleSystemLOD
{
unsigned char UnknownData_YZ45[0x1]; // 0x0000(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ParticleSysParam
// 0x0080
struct FParticleSysParam
{
struct FName Name; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EParticleSysParamType> ParamType; // 0x0008(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_UKTY[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float Scalar; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Scalar_Low; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Vector; // 0x0014(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Vector_Low; // 0x0020(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FColor Color; // 0x002C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class AActor* Actor; // 0x0030(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UMaterialInterface* Material; // 0x0038(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_COL1[0x40]; // 0x0040(0x0040) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ParticleSystemWorldManagerTickFunction
// 0x0008 (0x0058 - 0x0050)
struct FParticleSystemWorldManagerTickFunction : public FTickFunction
{
unsigned char UnknownData_3J22[0x8]; // 0x0050(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ParticleSystemReplayFrame
// 0x0010
struct FParticleSystemReplayFrame
{
unsigned char UnknownData_Q74O[0x10]; // 0x0000(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ParticleEmitterReplayFrame
// 0x0010
struct FParticleEmitterReplayFrame
{
unsigned char UnknownData_HN6G[0x10]; // 0x0000(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PhysicalAnimationData
// 0x0024
struct FPhysicalAnimationData
{
struct FName BodyName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIsLocalSimulation : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_017M[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float OrientationStrength; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AngularVelocityStrength; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PositionStrength; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float VelocityStrength; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxLinearForce; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxAngularForce; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TireFrictionScalePair
// 0x0010
struct FTireFrictionScalePair
{
class UTireType* TireType; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FrictionScale; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_7L8F[0x4]; // 0x000C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PhysicalAnimationProfile
// 0x002C
struct FPhysicalAnimationProfile
{
struct FName ProfileName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FPhysicalAnimationData PhysicalAnimationData; // 0x0008(0x0024) (Edit, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RepMovement
// 0x0034
struct FRepMovement
{
struct FVector LinearVelocity; // 0x0000(0x000C) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector AngularVelocity; // 0x000C(0x000C) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Location; // 0x0018(0x000C) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x0024(0x000C) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
unsigned char bSimulatedPhysicSleep : 1; // 0x0030(0x0001) BIT_FIELD (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRepPhysics : 1; // 0x0030(0x0001) BIT_FIELD (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EVectorQuantization LocationQuantizationLevel; // 0x0031(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EVectorQuantization VelocityQuantizationLevel; // 0x0032(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
ERotatorQuantization RotationQuantizationLevel; // 0x0033(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ConstraintBaseParams
// 0x0014
struct FConstraintBaseParams
{
float Stiffness; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Damping; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Restitution; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ContactDistance; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSoftConstraint : 1; // 0x0010(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_LW7L[0x3]; // 0x0011(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.Vector_NetQuantize100
// 0x0000 (0x000C - 0x000C)
struct FVector_NetQuantize100 : public FVector
{
};
// ScriptStruct Engine.LinearConstraint
// 0x0008 (0x001C - 0x0014)
struct FLinearConstraint : public FConstraintBaseParams
{
float Limit; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ELinearConstraintMotion> XMotion; // 0x0018(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ELinearConstraintMotion> YMotion; // 0x0019(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ELinearConstraintMotion> ZMotion; // 0x001A(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_55TV[0x1]; // 0x001B(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ConeConstraint
// 0x000C (0x0020 - 0x0014)
struct FConeConstraint : public FConstraintBaseParams
{
float Swing1LimitDegrees; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Swing2LimitDegrees; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAngularConstraintMotion> Swing1Motion; // 0x001C(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAngularConstraintMotion> Swing2Motion; // 0x001D(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_7COP[0x2]; // 0x001E(0x0002) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.WalkableSlopeOverride
// 0x0010
struct FWalkableSlopeOverride
{
TEnumAsByte<EWalkableSlopeBehavior> WalkableSlopeBehavior; // 0x0000(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_RO9O[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float WalkableSlopeAngle; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_WQZ3[0x8]; // 0x0008(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.RepAttachment
// 0x0040
struct FRepAttachment
{
class AActor* AttachParent; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantize100 LocationOffset; // 0x0008(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantize100 RelativeScale3D; // 0x0014(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator RotationOffset; // 0x0020(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FName AttachSocket; // 0x002C(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_MG11[0x4]; // 0x0034(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class USceneComponent* AttachComponent; // 0x0038(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TwistConstraint
// 0x0008 (0x001C - 0x0014)
struct FTwistConstraint : public FConstraintBaseParams
{
float TwistLimitDegrees; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAngularConstraintMotion> TwistMotion; // 0x0018(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VER4[0x3]; // 0x0019(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ConstraintDrive
// 0x0010
struct FConstraintDrive
{
float Stiffness; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Damping; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxForce; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnablePositionDrive : 1; // 0x000C(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableVelocityDrive : 1; // 0x000C(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_3LVX[0x3]; // 0x000D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LinearDriveConstraint
// 0x004C
struct FLinearDriveConstraint
{
struct FVector PositionTarget; // 0x0000(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector VelocityTarget; // 0x000C(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FConstraintDrive XDrive; // 0x0018(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FConstraintDrive YDrive; // 0x0028(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FConstraintDrive ZDrive; // 0x0038(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
unsigned char bEnablePositionDrive : 1; // 0x0048(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_6SP5[0x3]; // 0x0049(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.Vector_NetQuantize
// 0x0000 (0x000C - 0x000C)
struct FVector_NetQuantize : public FVector
{
};
// ScriptStruct Engine.Vector_NetQuantizeNormal
// 0x0000 (0x000C - 0x000C)
struct FVector_NetQuantizeNormal : public FVector
{
};
// ScriptStruct Engine.AngularDriveConstraint
// 0x004C
struct FAngularDriveConstraint
{
struct FConstraintDrive TwistDrive; // 0x0000(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FConstraintDrive SwingDrive; // 0x0010(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FConstraintDrive SlerpDrive; // 0x0020(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FRotator OrientationTarget; // 0x0030(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FVector AngularVelocityTarget; // 0x003C(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAngularDriveMode> AngularDriveMode; // 0x0048(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_6D8Y[0x3]; // 0x0049(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.HitResult
// 0x0088
struct FHitResult
{
unsigned char bBlockingHit : 1; // 0x0000(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bStartPenetrating : 1; // 0x0000(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_6TXZ[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int FaceIndex; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Time; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float distance; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantize Location; // 0x0010(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantize ImpactPoint; // 0x001C(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantizeNormal Normal; // 0x0028(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantizeNormal ImpactNormal; // 0x0034(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantize TraceStart; // 0x0040(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantize TraceEnd; // 0x004C(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PenetrationDepth; // 0x0058(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int Item; // 0x005C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TWeakObjectPtr<class UPhysicalMaterial> PhysMaterial; // 0x0060(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TWeakObjectPtr<class AActor> Actor; // 0x0068(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TWeakObjectPtr<class UPrimitiveComponent> Component; // 0x0070(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName BoneName; // 0x0078(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName MyBoneName; // 0x0080(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ConstraintProfileProperties
// 0x0104
struct FConstraintProfileProperties
{
float ProjectionLinearTolerance; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ProjectionAngularTolerance; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LinearBreakThreshold; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AngularBreakThreshold; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearConstraint LinearLimit; // 0x0010(0x001C) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FConeConstraint ConeLimit; // 0x002C(0x0020) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FTwistConstraint TwistLimit; // 0x004C(0x001C) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FLinearDriveConstraint LinearDrive; // 0x0068(0x004C) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FAngularDriveConstraint AngularDrive; // 0x00B4(0x004C) (Edit, NoDestructor, NativeAccessSpecifierPublic)
unsigned char bDisableCollision : 1; // 0x0100(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bParentDominates : 1; // 0x0100(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableProjection : 1; // 0x0100(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAngularBreakable : 1; // 0x0100(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLinearBreakable : 1; // 0x0100(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_E2FO[0x3]; // 0x0101(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PhysicsConstraintProfileHandle
// 0x010C
struct FPhysicsConstraintProfileHandle
{
struct FConstraintProfileProperties ProfileProperties; // 0x0000(0x0104) (NoDestructor, NativeAccessSpecifierPublic)
struct FName ProfileName; // 0x0104(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ChaosPhysicsSettings
// 0x0003
struct FChaosPhysicsSettings
{
EChaosThreadingMode DefaultThreadingModel; // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EChaosSolverTickMode DedicatedThreadTickMode; // 0x0001(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EChaosBufferMode DedicatedThreadBufferMode; // 0x0002(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PhysicalSurfaceName
// 0x000C
struct FPhysicalSurfaceName
{
TEnumAsByte<EPhysicalSurface> Type; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_1646[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName Name; // 0x0004(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CollisionResponseContainer
// 0x0020
struct FCollisionResponseContainer
{
TEnumAsByte<ECollisionResponse> WorldStatic; // 0x0000(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> WorldDynamic; // 0x0001(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> Pawn; // 0x0002(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> Visibility; // 0x0003(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> Camera; // 0x0004(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> PhysicsBody; // 0x0005(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> Vehicle; // 0x0006(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> Destructible; // 0x0007(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> EngineTraceChannel1; // 0x0008(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> EngineTraceChannel2; // 0x0009(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> EngineTraceChannel3; // 0x000A(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> EngineTraceChannel4; // 0x000B(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> EngineTraceChannel5; // 0x000C(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> EngineTraceChannel6; // 0x000D(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel1; // 0x000E(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel2; // 0x000F(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel3; // 0x0010(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel4; // 0x0011(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel5; // 0x0012(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel6; // 0x0013(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel7; // 0x0014(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel8; // 0x0015(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel9; // 0x0016(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel10; // 0x0017(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel11; // 0x0018(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel12; // 0x0019(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel13; // 0x001A(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel14; // 0x001B(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel15; // 0x001C(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel16; // 0x001D(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel17; // 0x001E(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> GameTraceChannel18; // 0x001F(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.DelegateArray
// 0x0010
struct FDelegateArray
{
TArray<struct FScriptDelegate> Delegates; // 0x0000(0x0010) (ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ViewTargetTransitionParams
// 0x0010
struct FViewTargetTransitionParams
{
float BlendTime; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EViewTargetBlendFunction> BlendFunction; // 0x0004(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_S8VK[0x3]; // 0x0005(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float BlendExp; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLockOutgoing : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EX77[0x3]; // 0x000D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ResponseChannel
// 0x000C
struct FResponseChannel
{
struct FName Channel; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> response; // 0x0008(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_T4HA[0x3]; // 0x0009(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CollisionResponse
// 0x0030
struct FCollisionResponse
{
struct FCollisionResponseContainer ResponseToChannels; // 0x0000(0x0020) (Transient, NoDestructor, NativeAccessSpecifierPrivate)
TArray<struct FResponseChannel> ResponseArray; // 0x0020(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.BodyInstance
// 0x0110
struct FBodyInstance
{
unsigned char UnknownData_GGI0[0x6]; // 0x0000(0x0006) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<ECollisionChannel> ObjectType; // 0x0006(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_YXKL[0x1]; // 0x0007(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<ECollisionEnabled> CollisionEnabled; // 0x0008(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_EY4Q[0x1]; // 0x0009(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
ESleepFamily SleepFamily; // 0x000A(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EDOFMode> DOFMode; // 0x000B(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseCCD : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bNotifyRigidBodyCollision : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ZZ84 : 1; // 0x000C(0x0001) BIT_FIELD (PADDING)
unsigned char bSimulatePhysics : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverrideMass : 1; // 0x000C(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableGravity : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAutoWeld : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bStartAwake : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGenerateWakeEvents : 1; // 0x000D(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUpdateMassWhenScaleChanges : 1; // 0x000D(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLockTranslation : 1; // 0x000D(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLockRotation : 1; // 0x000D(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLockXTranslation : 1; // 0x000D(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLockYTranslation : 1; // 0x000D(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLockZTranslation : 1; // 0x000D(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLockXRotation : 1; // 0x000D(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLockYRotation : 1; // 0x000E(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLockZRotation : 1; // 0x000E(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverrideMaxAngularVelocity : 1; // 0x000E(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_GE7H : 2; // 0x000E(0x0001) BIT_FIELD (PADDING)
unsigned char bOverrideMaxDepenetrationVelocity : 1; // 0x000E(0x0001) BIT_FIELD (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
unsigned char bOverrideWalkableSlopeOnInstance : 1; // 0x000E(0x0001) BIT_FIELD (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
unsigned char bInterpolateWhenSubStepping : 1; // 0x000E(0x0001) BIT_FIELD (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
unsigned char UnknownData_7I6Q[0xD]; // 0x000F(0x000D) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName CollisionProfileName; // 0x001C(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char PositionSolverIterationCount; // 0x0024(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char VelocitySolverIterationCount; // 0x0025(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_USY6[0x2]; // 0x0026(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FCollisionResponse CollisionResponses; // 0x0028(0x0030) (Edit, NativeAccessSpecifierPrivate)
float MaxDepenetrationVelocity; // 0x0058(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float MassInKgOverride; // 0x005C(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
unsigned char UnknownData_XSPA[0x8]; // 0x0060(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float LinearDamping; // 0x0068(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AngularDamping; // 0x006C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector CustomDOFPlaneNormal; // 0x0070(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector COMNudge; // 0x007C(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MassScale; // 0x0088(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector InertiaTensorScale; // 0x008C(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_QUEY[0x10]; // 0x0098(0x0010) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FWalkableSlopeOverride WalkableSlopeOverride; // 0x00A8(0x0010) (Edit, BlueprintVisible, BlueprintReadOnly, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, NativeAccessSpecifierProtected)
class UPhysicalMaterial* PhysMaterialOverride; // 0x00B8(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float MaxAngularVelocity; // 0x00C0(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CustomSleepThresholdMultiplier; // 0x00C4(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float StabilizationThresholdMultiplier; // 0x00C8(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PhysicsBlendWeight; // 0x00CC(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_3GFD[0x40]; // 0x00D0(0x0040) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CustomPrimitiveData
// 0x0010
struct FCustomPrimitiveData
{
TArray<float> Data; // 0x0000(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LightingChannels
// 0x0001
struct FLightingChannels
{
unsigned char bChannel0 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bChannel1 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bChannel2 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.WeightedBlendable
// 0x0010
struct FWeightedBlendable
{
float Weight; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EFVP[0x4]; // 0x0004(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UObject* Object; // 0x0008(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.WeightedBlendables
// 0x0010
struct FWeightedBlendables
{
TArray<struct FWeightedBlendable> Array; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PostProcessSettings
// 0x0530
struct FPostProcessSettings
{
unsigned char bOverride_WhiteTemp : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_WhiteTint : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorSaturation : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorContrast : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorGamma : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorGain : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorOffset : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorSaturationShadows : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorContrastShadows : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorGammaShadows : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorGainShadows : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorOffsetShadows : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorSaturationMidtones : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorContrastMidtones : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorGammaMidtones : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorGainMidtones : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorOffsetMidtones : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorSaturationHighlights : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorContrastHighlights : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorGammaHighlights : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorGainHighlights : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorOffsetHighlights : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorCorrectionShadowsMax : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorCorrectionHighlightsMin : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BlueCorrection : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ExpandGamut : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmWhitePoint : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmSaturation : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmChannelMixerRed : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmChannelMixerGreen : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmChannelMixerBlue : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmContrast : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmDynamicRange : 1; // 0x0004(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmHealAmount : 1; // 0x0004(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmToeAmount : 1; // 0x0004(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmShadowTint : 1; // 0x0004(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmShadowTintBlend : 1; // 0x0004(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmShadowTintAmount : 1; // 0x0004(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmSlope : 1; // 0x0004(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmToe : 1; // 0x0004(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmShoulder : 1; // 0x0005(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmBlackClip : 1; // 0x0005(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_FilmWhiteClip : 1; // 0x0005(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_SceneColorTint : 1; // 0x0005(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_SceneFringeIntensity : 1; // 0x0005(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ChromaticAberrationStartOffset : 1; // 0x0005(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientCubemapTint : 1; // 0x0005(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientCubemapIntensity : 1; // 0x0005(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomMethod : 1; // 0x0006(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomIntensity : 1; // 0x0006(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomThreshold : 1; // 0x0006(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom1Tint : 1; // 0x0006(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom1Size : 1; // 0x0006(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom2Size : 1; // 0x0006(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom2Tint : 1; // 0x0006(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom3Tint : 1; // 0x0006(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom3Size : 1; // 0x0007(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom4Tint : 1; // 0x0007(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom4Size : 1; // 0x0007(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom5Tint : 1; // 0x0007(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom5Size : 1; // 0x0007(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom6Tint : 1; // 0x0007(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_Bloom6Size : 1; // 0x0007(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomSizeScale : 1; // 0x0007(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomConvolutionTexture : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomConvolutionSize : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomConvolutionCenterUV : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomConvolutionPreFilter : 1; // 0x0008(0x0001) BIT_FIELD (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomConvolutionPreFilterMin : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomConvolutionPreFilterMax : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomConvolutionPreFilterMult : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomConvolutionBufferScale : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomDirtMaskIntensity : 1; // 0x0009(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomDirtMaskTint : 1; // 0x0009(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BloomDirtMask : 1; // 0x0009(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_CameraShutterSpeed : 1; // 0x0009(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_CameraISO : 1; // 0x0009(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AutoExposureMethod : 1; // 0x0009(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AutoExposureLowPercent : 1; // 0x0009(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AutoExposureHighPercent : 1; // 0x0009(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AutoExposureMinBrightness : 1; // 0x000A(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AutoExposureMaxBrightness : 1; // 0x000A(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AutoExposureCalibrationConstant : 1; // 0x000A(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AutoExposureSpeedUp : 1; // 0x000A(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AutoExposureSpeedDown : 1; // 0x000A(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AutoExposureBias : 1; // 0x000A(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AutoExposureBiasCurve : 1; // 0x000A(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_HistogramLogMin : 1; // 0x000A(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_HistogramLogMax : 1; // 0x000B(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LensFlareIntensity : 1; // 0x000B(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LensFlareTint : 1; // 0x000B(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LensFlareTints : 1; // 0x000B(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LensFlareBokehSize : 1; // 0x000B(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LensFlareBokehShape : 1; // 0x000B(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LensFlareThreshold : 1; // 0x000B(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_VignetteIntensity : 1; // 0x000B(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_GrainIntensity : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_GrainJitter : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionIntensity : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionStaticFraction : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionRadius : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionFadeDistance : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionFadeRadius : 1; // 0x000C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionDistance : 1; // 0x000C(0x0001) BIT_FIELD (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionRadiusInWS : 1; // 0x000D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionPower : 1; // 0x000D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionBias : 1; // 0x000D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionQuality : 1; // 0x000D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionMipBlend : 1; // 0x000D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionMipScale : 1; // 0x000D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_AmbientOcclusionMipThreshold : 1; // 0x000D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_93WO[0x2]; // 0x000E(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bOverride_RayTracingAO : 1; // 0x0010(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingAOSamplesPerPixel : 1; // 0x0010(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_QBLP[0x3]; // 0x0011(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bOverride_LPVIntensity : 1; // 0x0014(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVDirectionalOcclusionIntensity : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVDirectionalOcclusionRadius : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVDiffuseOcclusionExponent : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVSpecularOcclusionExponent : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVDiffuseOcclusionIntensity : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVSpecularOcclusionIntensity : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVSize : 1; // 0x0014(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVSecondaryOcclusionIntensity : 1; // 0x0015(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVSecondaryBounceIntensity : 1; // 0x0015(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVGeometryVolumeBias : 1; // 0x0015(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVVplInjectionBias : 1; // 0x0015(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVEmissiveInjectionIntensity : 1; // 0x0015(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVFadeRange : 1; // 0x0015(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_LPVDirectionalOcclusionFadeRange : 1; // 0x0015(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_IndirectLightingColor : 1; // 0x0015(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_IndirectLightingIntensity : 1; // 0x0016(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorGradingIntensity : 1; // 0x0016(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ColorGradingLUT : 1; // 0x0016(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldFocalDistance : 1; // 0x0016(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldFstop : 1; // 0x0016(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldMinFstop : 1; // 0x0016(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldBladeCount : 1; // 0x0016(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldSensorWidth : 1; // 0x0016(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldDepthBlurRadius : 1; // 0x0017(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldDepthBlurAmount : 1; // 0x0017(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldFocalRegion : 1; // 0x0017(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldNearTransitionRegion : 1; // 0x0017(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldFarTransitionRegion : 1; // 0x0017(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldScale : 1; // 0x0017(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldNearBlurSize : 1; // 0x0017(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldFarBlurSize : 1; // 0x0017(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_MobileHQGaussian : 1; // 0x0018(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldOcclusion : 1; // 0x0018(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldSkyFocusDistance : 1; // 0x0018(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DepthOfFieldVignetteSize : 1; // 0x0018(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_MotionBlurAmount : 1; // 0x0018(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_MotionBlurMax : 1; // 0x0018(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_MotionBlurTargetFPS : 1; // 0x0018(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_MotionBlurPerObjectSize : 1; // 0x0018(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ScreenPercentage : 1; // 0x0019(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ScreenSpaceReflectionIntensity : 1; // 0x0019(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ScreenSpaceReflectionQuality : 1; // 0x0019(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ScreenSpaceReflectionMaxRoughness : 1; // 0x0019(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ScreenSpaceReflectionRoughnessScale : 1; // 0x0019(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_7IIV[0x2]; // 0x001A(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bOverride_ReflectionsType : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingReflectionsMaxRoughness : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingReflectionsMaxBounces : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingReflectionsSamplesPerPixel : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingReflectionsShadows : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_TranslucencyType : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingTranslucencyMaxRoughness : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingTranslucencyRefractionRays : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingTranslucencySamplesPerPixel : 1; // 0x001D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingTranslucencyShadows : 1; // 0x001D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingTranslucencyRefraction : 1; // 0x001D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingGI : 1; // 0x001D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingGIMaxBounces : 1; // 0x001D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_RayTracingGISamplesPerPixel : 1; // 0x001D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_PathTracingMaxBounces : 1; // 0x001D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_PathTracingSamplesPerPixel : 1; // 0x001D(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_1AEP[0x2]; // 0x001E(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bMobileHQGaussian : 1; // 0x0020(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EBloomMethod> BloomMethod; // 0x0021(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAutoExposureMethod> AutoExposureMethod; // 0x0022(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_RHOB[0x1]; // 0x0023(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float WhiteTemp; // 0x0024(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float WhiteTint; // 0x0028(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_B9EH[0x4]; // 0x002C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FVector4 ColorSaturation; // 0x0030(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorContrast; // 0x0040(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorGamma; // 0x0050(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorGain; // 0x0060(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorOffset; // 0x0070(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorSaturationShadows; // 0x0080(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorContrastShadows; // 0x0090(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorGammaShadows; // 0x00A0(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorGainShadows; // 0x00B0(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorOffsetShadows; // 0x00C0(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorSaturationMidtones; // 0x00D0(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorContrastMidtones; // 0x00E0(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorGammaMidtones; // 0x00F0(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorGainMidtones; // 0x0100(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorOffsetMidtones; // 0x0110(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorSaturationHighlights; // 0x0120(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorContrastHighlights; // 0x0130(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorGammaHighlights; // 0x0140(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorGainHighlights; // 0x0150(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 ColorOffsetHighlights; // 0x0160(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ColorCorrectionHighlightsMin; // 0x0170(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ColorCorrectionShadowsMax; // 0x0174(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BlueCorrection; // 0x0178(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ExpandGamut; // 0x017C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmSlope; // 0x0180(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmToe; // 0x0184(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmShoulder; // 0x0188(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmBlackClip; // 0x018C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmWhiteClip; // 0x0190(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor FilmWhitePoint; // 0x0194(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor FilmShadowTint; // 0x01A4(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmShadowTintBlend; // 0x01B4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmShadowTintAmount; // 0x01B8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmSaturation; // 0x01BC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor FilmChannelMixerRed; // 0x01C0(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor FilmChannelMixerGreen; // 0x01D0(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor FilmChannelMixerBlue; // 0x01E0(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmContrast; // 0x01F0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmToeAmount; // 0x01F4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmHealAmount; // 0x01F8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FilmDynamicRange; // 0x01FC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor SceneColorTint; // 0x0200(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SceneFringeIntensity; // 0x0210(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ChromaticAberrationStartOffset; // 0x0214(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BloomIntensity; // 0x0218(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BloomThreshold; // 0x021C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BloomSizeScale; // 0x0220(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bloom1Size; // 0x0224(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bloom2Size; // 0x0228(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bloom3Size; // 0x022C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bloom4Size; // 0x0230(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bloom5Size; // 0x0234(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bloom6Size; // 0x0238(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Bloom1Tint; // 0x023C(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Bloom2Tint; // 0x024C(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Bloom3Tint; // 0x025C(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Bloom4Tint; // 0x026C(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Bloom5Tint; // 0x027C(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Bloom6Tint; // 0x028C(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BloomConvolutionSize; // 0x029C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UTexture2D* BloomConvolutionTexture; // 0x02A0(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D BloomConvolutionCenterUV; // 0x02A8(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BloomConvolutionPreFilterMin; // 0x02B0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BloomConvolutionPreFilterMax; // 0x02B4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BloomConvolutionPreFilterMult; // 0x02B8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BloomConvolutionBufferScale; // 0x02BC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UTexture* BloomDirtMask; // 0x02C0(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BloomDirtMaskIntensity; // 0x02C8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor BloomDirtMaskTint; // 0x02CC(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor AmbientCubemapTint; // 0x02DC(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientCubemapIntensity; // 0x02EC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UTextureCube* AmbientCubemap; // 0x02F0(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CameraShutterSpeed; // 0x02F8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CameraISO; // 0x02FC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldFstop; // 0x0300(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldMinFstop; // 0x0304(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int DepthOfFieldBladeCount; // 0x0308(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AutoExposureBias; // 0x030C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UCurveFloat* AutoExposureBiasCurve; // 0x0310(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AutoExposureLowPercent; // 0x0318(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AutoExposureHighPercent; // 0x031C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AutoExposureMinBrightness; // 0x0320(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AutoExposureMaxBrightness; // 0x0324(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AutoExposureSpeedUp; // 0x0328(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AutoExposureSpeedDown; // 0x032C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HistogramLogMin; // 0x0330(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HistogramLogMax; // 0x0334(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AutoExposureCalibrationConstant; // 0x0338(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LensFlareIntensity; // 0x033C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor LensFlareTint; // 0x0340(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LensFlareBokehSize; // 0x0350(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LensFlareThreshold; // 0x0354(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UTexture* LensFlareBokehShape; // 0x0358(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor LensFlareTints[0x8]; // 0x0360(0x0080) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float VignetteIntensity; // 0x03E0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float GrainJitter; // 0x03E4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float GrainIntensity; // 0x03E8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionIntensity; // 0x03EC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionStaticFraction; // 0x03F0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionRadius; // 0x03F4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char AmbientOcclusionRadiusInWS : 1; // 0x03F8(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_4GVL[0x3]; // 0x03F9(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float AmbientOcclusionFadeDistance; // 0x03FC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionFadeRadius; // 0x0400(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionDistance; // 0x0404(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionPower; // 0x0408(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionBias; // 0x040C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionQuality; // 0x0410(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionMipBlend; // 0x0414(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionMipScale; // 0x0418(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionMipThreshold; // 0x041C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char RayTracingAO : 1; // 0x0420(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EQ4O[0x3]; // 0x0421(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int RayTracingAOSamplesPerPixel; // 0x0424(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor IndirectLightingColor; // 0x0428(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float IndirectLightingIntensity; // 0x0438(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char RayTracingGI : 1; // 0x043C(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_A1QD[0x3]; // 0x043D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int RayTracingGIMaxBounces; // 0x0440(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int RayTracingGISamplesPerPixel; // 0x0444(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ColorGradingIntensity; // 0x0448(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_NYRI[0x4]; // 0x044C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UTexture* ColorGradingLUT; // 0x0450(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldSensorWidth; // 0x0458(0x0004) (BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldFocalDistance; // 0x045C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldDepthBlurAmount; // 0x0460(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldDepthBlurRadius; // 0x0464(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldFocalRegion; // 0x0468(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldNearTransitionRegion; // 0x046C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldFarTransitionRegion; // 0x0470(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldScale; // 0x0474(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldNearBlurSize; // 0x0478(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldFarBlurSize; // 0x047C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldOcclusion; // 0x0480(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldSkyFocusDistance; // 0x0484(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DepthOfFieldVignetteSize; // 0x0488(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MotionBlurAmount; // 0x048C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MotionBlurMax; // 0x0490(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MotionBlurTargetFPS; // 0x0494(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MotionBlurPerObjectSize; // 0x0498(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVIntensity; // 0x049C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVVplInjectionBias; // 0x04A0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVSize; // 0x04A4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVSecondaryOcclusionIntensity; // 0x04A8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVSecondaryBounceIntensity; // 0x04AC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVGeometryVolumeBias; // 0x04B0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVEmissiveInjectionIntensity; // 0x04B4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVDirectionalOcclusionIntensity; // 0x04B8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVDirectionalOcclusionRadius; // 0x04BC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVDiffuseOcclusionExponent; // 0x04C0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVSpecularOcclusionExponent; // 0x04C4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVDiffuseOcclusionIntensity; // 0x04C8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVSpecularOcclusionIntensity; // 0x04CC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EReflectionsType ReflectionsType; // 0x04D0(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_QZI0[0x3]; // 0x04D1(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float ScreenSpaceReflectionIntensity; // 0x04D4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ScreenSpaceReflectionQuality; // 0x04D8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ScreenSpaceReflectionMaxRoughness; // 0x04DC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float RayTracingReflectionsMaxRoughness; // 0x04E0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int RayTracingReflectionsMaxBounces; // 0x04E4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int RayTracingReflectionsSamplesPerPixel; // 0x04E8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EReflectedAndRefractedRayTracedShadows RayTracingReflectionsShadows; // 0x04EC(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
ETranslucencyType TranslucencyType; // 0x04ED(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_GD4I[0x2]; // 0x04EE(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float RayTracingTranslucencyMaxRoughness; // 0x04F0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int RayTracingTranslucencyRefractionRays; // 0x04F4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int RayTracingTranslucencySamplesPerPixel; // 0x04F8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EReflectedAndRefractedRayTracedShadows RayTracingTranslucencyShadows; // 0x04FC(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char RayTracingTranslucencyRefraction : 1; // 0x04FD(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ZUYM[0x2]; // 0x04FE(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int PathTracingMaxBounces; // 0x0500(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int PathTracingSamplesPerPixel; // 0x0504(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVFadeRange; // 0x0508(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPVDirectionalOcclusionFadeRange; // 0x050C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ScreenPercentage; // 0x0510(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_5A79[0x4]; // 0x0514(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FWeightedBlendables WeightedBlendables; // 0x0518(0x0010) (Edit, BlueprintVisible, NativeAccessSpecifierPublic)
unsigned char UnknownData_YOTJ[0x8]; // 0x0528(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MinimalViewInfo
// 0x05C0
struct FMinimalViewInfo
{
struct FVector Location; // 0x0000(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x000C(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
float FOV; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DesiredFOV; // 0x001C(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OrthoWidth; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OrthoNearClipPlane; // 0x0024(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OrthoFarClipPlane; // 0x0028(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AspectRatio; // 0x002C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bConstrainAspectRatio : 1; // 0x0030(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseFieldOfViewForLOD : 1; // 0x0030(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_QAKQ[0x3]; // 0x0031(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<ECameraProjectionMode> ProjectionMode; // 0x0034(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_O3UA[0x3]; // 0x0035(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float PostProcessBlendWeight; // 0x0038(0x0004) (BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_UBB2[0x4]; // 0x003C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FPostProcessSettings PostProcessSettings; // 0x0040(0x0530) (BlueprintVisible, NativeAccessSpecifierPublic)
struct FVector2D OffCenterProjectionOffset; // 0x0570(0x0008) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, Transient, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_0GUL[0x48]; // 0x0578(0x0048) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TViewTarget
// 0x05E0
struct FTViewTarget
{
class AActor* Target; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_0OB1[0x8]; // 0x0008(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FMinimalViewInfo POV; // 0x0010(0x05C0) (Edit, BlueprintVisible, NativeAccessSpecifierPublic)
class APlayerState* PlayerState; // 0x05D0(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
unsigned char UnknownData_LMWU[0x8]; // 0x05D8(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CameraCacheEntry
// 0x05D0
struct FCameraCacheEntry
{
float Timestamp; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_2RTA[0xC]; // 0x0004(0x000C) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FMinimalViewInfo POV; // 0x0010(0x05C0) (NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.UpdateLevelVisibilityLevelInfo
// 0x000C
struct FUpdateLevelVisibilityLevelInfo
{
struct FName PackageName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIsVisible : 1; // 0x0008(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_O2MM[0x3]; // 0x0009(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.UpdateLevelStreamingLevelStatus
// 0x0010
struct FUpdateLevelStreamingLevelStatus
{
struct FName PackageName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LODIndex; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bNewShouldBeLoaded : 1; // 0x000C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bNewShouldBeVisible : 1; // 0x000C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bNewShouldBlockOnLoad : 1; // 0x000C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_S5WY[0x3]; // 0x000D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.InputActionSpeechMapping
// 0x0010
struct FInputActionSpeechMapping
{
struct FName ActionName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
struct FName SpeechKeyword; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.InputAxisKeyMapping
// 0x0028
struct FInputAxisKeyMapping
{
struct FName AxisName; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Scale; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_PWJK[0x4]; // 0x000C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FKey Key; // 0x0010(0x0018) (Edit, BlueprintVisible, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InputActionKeyMapping
// 0x0028
struct FInputActionKeyMapping
{
struct FName ActionName; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bShift : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCtrl : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAlt : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCmd : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_N27D[0x7]; // 0x0009(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FKey Key; // 0x0010(0x0018) (Edit, BlueprintVisible, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InputAxisProperties
// 0x0010
struct FInputAxisProperties
{
float DeadZone; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Sensitivity; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Exponent; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bInvert : 1; // 0x000C(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_JTGD[0x3]; // 0x000D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.InputAxisConfigEntry
// 0x0018
struct FInputAxisConfigEntry
{
struct FName AxisKeyName; // 0x0000(0x0008) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FInputAxisProperties AxisProperties; // 0x0008(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.KeyBind
// 0x0030
struct FKeyBind
{
struct FKey Key; // 0x0000(0x0018) (Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString Command; // 0x0018(0x0010) (ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char Control : 1; // 0x0028(0x0001) BIT_FIELD (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char Shift : 1; // 0x0028(0x0001) BIT_FIELD (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char Alt : 1; // 0x0028(0x0001) BIT_FIELD (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char Cmd : 1; // 0x0028(0x0001) BIT_FIELD (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIgnoreCtrl : 1; // 0x0028(0x0001) BIT_FIELD (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIgnoreShift : 1; // 0x0028(0x0001) BIT_FIELD (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIgnoreAlt : 1; // 0x0028(0x0001) BIT_FIELD (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIgnoreCmd : 1; // 0x0028(0x0001) BIT_FIELD (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bDisabled : 1; // 0x0029(0x0001) BIT_FIELD (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_HDVL[0x6]; // 0x002A(0x0006) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PlayerMuteList
// 0x0038
struct FPlayerMuteList
{
unsigned char UnknownData_JXBY[0x30]; // 0x0000(0x0030) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
bool bHasVoiceHandshakeCompleted; // 0x0030(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_DPCA[0x3]; // 0x0031(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int VoiceChannelIdx; // 0x0034(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SmartName
// 0x000C
struct FSmartName
{
struct FName DisplayName; // 0x0000(0x0008) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_HDJK[0x4]; // 0x0008(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PoseData
// 0x0070
struct FPoseData
{
TArray<struct FTransform> LocalSpacePose; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TMap<int, int> TrackToBufferIndex; // 0x0010(0x0050) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<float> CurveData; // 0x0060(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimCurveBase
// 0x0018
struct FAnimCurveBase
{
struct FName LastObservedName; // 0x0000(0x0008) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FSmartName Name; // 0x0008(0x000C) (NoDestructor, NativeAccessSpecifierPublic)
int CurveTypeFlags; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.PoseDataContainer
// 0x0090
struct FPoseDataContainer
{
TArray<struct FSmartName> PoseNames; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPrivate)
TArray<struct FName> Tracks; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPrivate)
TMap<struct FName, int> TrackMap; // 0x0020(0x0050) (ZeroConstructor, Transient, NativeAccessSpecifierPrivate)
TArray<struct FPoseData> Poses; // 0x0070(0x0010) (ZeroConstructor, NativeAccessSpecifierPrivate)
TArray<struct FAnimCurveBase> Curves; // 0x0080(0x0010) (ZeroConstructor, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.PreviewAttachedObjectPair
// 0x0038
struct FPreviewAttachedObjectPair
{
unsigned char AttachedObject[0x28]; // 0x0000(0x0028) UNKNOWN PROPERTY: SoftObjectProperty Engine.PreviewAttachedObjectPair.AttachedObject
class UObject* Object; // 0x0028(0x0008) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
struct FName AttachedTo; // 0x0030(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PreviewAssetAttachContainer
// 0x0010
struct FPreviewAssetAttachContainer
{
TArray<struct FPreviewAttachedObjectPair> AttachedObjects; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.PreviewMeshCollectionEntry
// 0x0028
struct FPreviewMeshCollectionEntry
{
unsigned char SkeletalMesh[0x28]; // 0x0000(0x0028) UNKNOWN PROPERTY: SoftObjectProperty Engine.PreviewMeshCollectionEntry.SkeletalMesh
};
// ScriptStruct Engine.ActorComponentDuplicatedObjectData
// 0x0010
struct FActorComponentDuplicatedObjectData
{
unsigned char UnknownData_ZKHZ[0x10]; // 0x0000(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ActorComponentInstanceData
// 0x0058
struct FActorComponentInstanceData
{
unsigned char UnknownData_UQPQ[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UObject* SourceComponentTemplate; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
EComponentCreationMethod SourceComponentCreationMethod; // 0x0010(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
unsigned char UnknownData_X1AP[0x3]; // 0x0011(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int SourceComponentTypeSerializedIndex; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TArray<unsigned char> SavedProperties; // 0x0018(0x0010) (ZeroConstructor, Protected, NativeAccessSpecifierProtected)
TArray<struct FActorComponentDuplicatedObjectData> DuplicatedObjects; // 0x0028(0x0010) (ZeroConstructor, Protected, NativeAccessSpecifierProtected)
TArray<class UObject*> ReferencedObjects; // 0x0038(0x0010) (ZeroConstructor, Protected, NativeAccessSpecifierProtected)
TArray<struct FName> ReferencedNames; // 0x0048(0x0010) (ZeroConstructor, Protected, NativeAccessSpecifierProtected)
};
// ScriptStruct Engine.SceneComponentInstanceData
// 0x0050 (0x00A8 - 0x0058)
struct FSceneComponentInstanceData : public FActorComponentInstanceData
{
TMap<class USceneComponent*, struct FTransform> AttachedInstanceComponents; // 0x0058(0x0050) (ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PrimitiveComponentInstanceData
// 0x0048 (0x00F0 - 0x00A8)
struct FPrimitiveComponentInstanceData : public FSceneComponentInstanceData
{
unsigned char UnknownData_796T[0x8]; // 0x00A8(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FTransform ComponentTransform; // 0x00B0(0x0030) (IsPlainOldData, NoDestructor, NativeAccessSpecifierPrivate)
int VisibilityId; // 0x00E0(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_RMI1[0x4]; // 0x00E4(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UPrimitiveComponent* LODParent; // 0x00E8(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.SpriteCategoryInfo
// 0x0038
struct FSpriteCategoryInfo
{
struct FName Category; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FText DisplayName; // 0x0008(0x0018) (NativeAccessSpecifierPublic)
struct FText Description; // 0x0020(0x0018) (NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CompressedRichCurve
// 0x0018
struct FCompressedRichCurve
{
unsigned char UnknownData_CI4W[0x18]; // 0x0000(0x0018) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.RigTransformConstraint
// 0x0010
struct FRigTransformConstraint
{
TEnumAsByte<EConstraintTransform> TranformType; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VH3D[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName ParentSpace; // 0x0004(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Weight; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TransformBaseConstraint
// 0x0010
struct FTransformBaseConstraint
{
TArray<struct FRigTransformConstraint> TransformConstraints; // 0x0000(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TransformBase
// 0x0028
struct FTransformBase
{
struct FName Node; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FTransformBaseConstraint Constraints[0x2]; // 0x0008(0x0020) (Edit, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.Node
// 0x0060
struct FNode
{
struct FName Name; // 0x0000(0x0008) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ParentName; // 0x0008(0x0008) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FTransform Transform; // 0x0010(0x0030) (IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FString DisplayName; // 0x0040(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAdvanced; // 0x0050(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_7XZ1[0xF]; // 0x0051(0x000F) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.RootMotionSourceStatus
// 0x0001
struct FRootMotionSourceStatus
{
unsigned char Flags; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RootMotionSourceSettings
// 0x0001
struct FRootMotionSourceSettings
{
unsigned char Flags; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RootMotionMovementParams
// 0x0040
struct FRootMotionMovementParams
{
bool bHasRootMotion; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_YR85[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float BlendWeight; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_4SHR[0x8]; // 0x0008(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FTransform RootMotionTransform; // 0x0010(0x0030) (IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RootMotionFinishVelocitySettings
// 0x0014
struct FRootMotionFinishVelocitySettings
{
ERootMotionFinishVelocityMode Mode; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_PUDM[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FVector SetVelocity; // 0x0004(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ClampVelocity; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RootMotionSource
// 0x0098
struct FRootMotionSource
{
unsigned char UnknownData_CJ3W[0x10]; // 0x0000(0x0010) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
uint16_t Priority; // 0x0010(0x0002) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint16_t LocalID; // 0x0012(0x0002) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
ERootMotionAccumulateMode AccumulateMode; // 0x0014(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_SAXU[0x3]; // 0x0015(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName InstanceName; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float StartTime; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CurrentTime; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PreviousTime; // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Duration; // 0x002C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRootMotionSourceStatus Status; // 0x0030(0x0001) (NoDestructor, NativeAccessSpecifierPublic)
struct FRootMotionSourceSettings Settings; // 0x0031(0x0001) (NoDestructor, NativeAccessSpecifierPublic)
bool bInLocalSpace; // 0x0032(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VPTR[0xD]; // 0x0033(0x000D) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FRootMotionMovementParams RootMotionParams; // 0x0040(0x0040) (NoDestructor, NativeAccessSpecifierPublic)
struct FRootMotionFinishVelocitySettings FinishVelocityParams; // 0x0080(0x0014) (NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_FLYI[0x4]; // 0x0094(0x0004) Fix Super Size
};
// ScriptStruct Engine.RootMotionSource_JumpForce
// 0x0038 (0x00D0 - 0x0098)
struct FRootMotionSource_JumpForce : public FRootMotionSource
{
struct FRotator Rotation; // 0x0098(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
float distance; // 0x00A4(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Height; // 0x00A8(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bDisableTimeout; // 0x00AC(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_FGPP[0x3]; // 0x00AD(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UCurveVector* PathOffsetCurve; // 0x00B0(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UCurveFloat* TimeMappingCurve; // 0x00B8(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Y46C[0x10]; // 0x00C0(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.RootMotionSource_MoveToDynamicForce
// 0x0038 (0x00D0 - 0x0098)
struct FRootMotionSource_MoveToDynamicForce : public FRootMotionSource
{
struct FVector StartLocation; // 0x0098(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector InitialTargetLocation; // 0x00A4(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector TargetLocation; // 0x00B0(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bRestrictSpeedToExpected; // 0x00BC(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EAQL[0x3]; // 0x00BD(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UCurveVector* PathOffsetCurve; // 0x00C0(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UCurveFloat* TimeMappingCurve; // 0x00C8(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RootMotionSource_MoveToForce
// 0x0028 (0x00C0 - 0x0098)
struct FRootMotionSource_MoveToForce : public FRootMotionSource
{
struct FVector StartLocation; // 0x0098(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector TargetLocation; // 0x00A4(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bRestrictSpeedToExpected; // 0x00B0(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_3OH5[0x7]; // 0x00B1(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UCurveVector* PathOffsetCurve; // 0x00B8(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RootMotionSource_RadialForce
// 0x0048 (0x00E0 - 0x0098)
struct FRootMotionSource_RadialForce : public FRootMotionSource
{
struct FVector Location; // 0x0098(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_CAJF[0x4]; // 0x00A4(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class AActor* LocationActor; // 0x00A8(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Radius; // 0x00B0(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Strength; // 0x00B4(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bIsPush; // 0x00B8(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bNoZForce; // 0x00B9(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_3QFY[0x6]; // 0x00BA(0x0006) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UCurveFloat* StrengthDistanceFalloff; // 0x00C0(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UCurveFloat* StrengthOverTime; // 0x00C8(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bUseFixedWorldDirection; // 0x00D0(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_4NJP[0x3]; // 0x00D1(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FRotator FixedWorldDirection; // 0x00D4(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RootMotionSource_ConstantForce
// 0x0018 (0x00B0 - 0x0098)
struct FRootMotionSource_ConstantForce : public FRootMotionSource
{
struct FVector Force; // 0x0098(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_90K6[0x4]; // 0x00A4(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UCurveFloat* StrengthOverTime; // 0x00A8(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CameraExposureSettings
// 0x0038
struct FCameraExposureSettings
{
TEnumAsByte<EAutoExposureMethod> Method; // 0x0000(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_MFHP[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float LowPercent; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HighPercent; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MinBrightness; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxBrightness; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SpeedUp; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SpeedDown; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bias; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UCurveFloat* BiasCurve; // 0x0020(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HistogramLogMin; // 0x0028(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HistogramLogMax; // 0x002C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CalibrationConstant; // 0x0030(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_6DLI[0x4]; // 0x0034(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.GaussianSumBloomSettings
// 0x0084
struct FGaussianSumBloomSettings
{
float Intensity; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Threshold; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SizeScale; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Filter1Size; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Filter2Size; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Filter3Size; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Filter4Size; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Filter5Size; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Filter6Size; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Filter1Tint; // 0x0024(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Filter2Tint; // 0x0034(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Filter3Tint; // 0x0044(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Filter4Tint; // 0x0054(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Filter5Tint; // 0x0064(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Filter6Tint; // 0x0074(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ConvolutionBloomSettings
// 0x0028
struct FConvolutionBloomSettings
{
class UTexture2D* Texture; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Size; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D CenterUV; // 0x000C(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PreFilterMin; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PreFilterMax; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PreFilterMult; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BufferScale; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_M1RR[0x4]; // 0x0024(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LensBloomSettings
// 0x00B8
struct FLensBloomSettings
{
struct FGaussianSumBloomSettings GaussianSum; // 0x0000(0x0084) (Edit, BlueprintVisible, Interp, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_TM1H[0x4]; // 0x0084(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FConvolutionBloomSettings Convolution; // 0x0088(0x0028) (Edit, BlueprintVisible, Interp, NoDestructor, NativeAccessSpecifierPublic)
TEnumAsByte<EBloomMethod> Method; // 0x00B0(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_IXOG[0x7]; // 0x00B1(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LensImperfectionSettings
// 0x0020
struct FLensImperfectionSettings
{
class UTexture* DirtMask; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DirtMaskIntensity; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor DirtMaskTint; // 0x000C(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_KCEY[0x4]; // 0x001C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LensSettings
// 0x00E0
struct FLensSettings
{
struct FLensBloomSettings Bloom; // 0x0000(0x00B8) (Edit, BlueprintVisible, Interp, NoDestructor, NativeAccessSpecifierPublic)
struct FLensImperfectionSettings Imperfections; // 0x00B8(0x0020) (Edit, BlueprintVisible, Interp, NoDestructor, NativeAccessSpecifierPublic)
float ChromaticAberration; // 0x00D8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_URDN[0x4]; // 0x00DC(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.FilmStockSettings
// 0x0014
struct FFilmStockSettings
{
float Slope; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Toe; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Shoulder; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BlackClip; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float WhiteClip; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ColorGradePerRangeSettings
// 0x0050
struct FColorGradePerRangeSettings
{
struct FVector4 Saturation; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 Contrast; // 0x0010(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 Gamma; // 0x0020(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 Gain; // 0x0030(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 Offset; // 0x0040(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ColorGradingSettings
// 0x0150
struct FColorGradingSettings
{
struct FColorGradePerRangeSettings Global; // 0x0000(0x0050) (Edit, BlueprintVisible, Interp, NoDestructor, NativeAccessSpecifierPublic)
struct FColorGradePerRangeSettings Shadows; // 0x0050(0x0050) (Edit, BlueprintVisible, Interp, NoDestructor, NativeAccessSpecifierPublic)
struct FColorGradePerRangeSettings Midtones; // 0x00A0(0x0050) (Edit, BlueprintVisible, Interp, NoDestructor, NativeAccessSpecifierPublic)
struct FColorGradePerRangeSettings Highlights; // 0x00F0(0x0050) (Edit, BlueprintVisible, Interp, NoDestructor, NativeAccessSpecifierPublic)
float ShadowsMax; // 0x0140(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HighlightsMin; // 0x0144(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_WCHL[0x8]; // 0x0148(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.EngineShowFlagsSetting
// 0x0018
struct FEngineShowFlagsSetting
{
struct FString ShowFlagName; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool Enabled; // 0x0010(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_LEWK[0x7]; // 0x0011(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.KeyHandleMap
// 0x0060
struct FKeyHandleMap
{
unsigned char UnknownData_ASOF[0x60]; // 0x0000(0x0060) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.IndexedCurve
// 0x0068
struct FIndexedCurve
{
unsigned char UnknownData_SAX5[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FKeyHandleMap KeyHandlesToIndices; // 0x0008(0x0060) (Transient, Protected, NativeAccessSpecifierProtected)
};
// ScriptStruct Engine.RealCurve
// 0x0008 (0x0070 - 0x0068)
struct FRealCurve : public FIndexedCurve
{
TEnumAsByte<ERichCurveExtrapolation> PreInfinityExtrap; // 0x0068(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ERichCurveExtrapolation> PostInfinityExtrap; // 0x0069(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_XD19[0x2]; // 0x006A(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float DefaultValue; // 0x006C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ActiveForceFeedbackEffect
// 0x0018
struct FActiveForceFeedbackEffect
{
class UForceFeedbackEffect* ForceFeedbackEffect; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_NDAR[0x10]; // 0x0008(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SimpleCurveKey
// 0x0008
struct FSimpleCurveKey
{
float Time; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Value; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SimpleCurve
// 0x0018 (0x0088 - 0x0070)
struct FSimpleCurve : public FRealCurve
{
TEnumAsByte<ERichCurveInterpMode> InterpMode; // 0x0070(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_XOQJ[0x7]; // 0x0071(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FSimpleCurveKey> Keys; // 0x0078(0x0010) (Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SingleAnimationPlayData
// 0x0018
struct FSingleAnimationPlayData
{
class UAnimationAsset* AnimToPlay; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSavedLooping : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSavedPlaying : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_JB0N[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float SavedPosition; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SavedPlayRate; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_WBYS[0x4]; // 0x0014(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MeshUVChannelInfo
// 0x0014
struct FMeshUVChannelInfo
{
bool bInitialized; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bOverrideDensities; // 0x0001(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_K2CV[0x2]; // 0x0002(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float LocalUVDensities[0x4]; // 0x0004(0x0010) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SkeletalMaterial
// 0x0028
struct FSkeletalMaterial
{
class UMaterialInterface* MaterialInterface; // 0x0000(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName MaterialSlotName; // 0x0008(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FMeshUVChannelInfo UVChannelData; // 0x0010(0x0014) (Edit, BlueprintVisible, BlueprintReadOnly, EditConst, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_M4QY[0x4]; // 0x0024(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ClothPhysicsProperties_Legacy
// 0x0050
struct FClothPhysicsProperties_Legacy
{
float VerticalResistance; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HorizontalResistance; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BendResistance; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ShearResistance; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Friction; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Damping; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TetherStiffness; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TetherLimit; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Drag; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float StiffnessFrequency; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float GravityScale; // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MassScale; // 0x002C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float InertiaBlend; // 0x0030(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SelfCollisionThickness; // 0x0034(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SelfCollisionSquashScale; // 0x0038(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SelfCollisionStiffness; // 0x003C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SolverFrequency; // 0x0040(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FiberCompression; // 0x0044(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FiberExpansion; // 0x0048(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FiberResistance; // 0x004C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ClothingAssetData_Legacy
// 0x0078
struct FClothingAssetData_Legacy
{
struct FName AssetName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString ApexFileName; // 0x0008(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bClothPropertiesChanged; // 0x0018(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_XMA8[0x3]; // 0x0019(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FClothPhysicsProperties_Legacy PhysicsProperties; // 0x001C(0x0050) (NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_2BSR[0xC]; // 0x006C(0x000C) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PerPlatformFloat
// 0x0004
struct FPerPlatformFloat
{
float Default; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.UniqueNetIdRepl
// 0x0027 (0x0028 - 0x0001)
struct FUniqueNetIdRepl : public FUniqueNetIdWrapper
{
unsigned char UnknownData_LEU4[0x17]; // 0x0001(0x0017) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<unsigned char> ReplicationBytes; // 0x0018(0x0010) (ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
};
// ScriptStruct Engine.SkeletalMeshOptimizationSettings
// 0x003C
struct FSkeletalMeshOptimizationSettings
{
TEnumAsByte<ESkeletalMeshTerminationCriterion> TerminationCriterion; // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_BGBZ[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float NumOfTrianglesPercentage; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NumOfVertPercentage; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint32_t MaxNumOfTriangles; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint32_t MaxNumOfVerts; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxDeviationPercentage; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ESkeletalMeshOptimizationType> ReductionMethod; // 0x0018(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ESkeletalMeshOptimizationImportance> SilhouetteImportance; // 0x0019(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ESkeletalMeshOptimizationImportance> TextureImportance; // 0x001A(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ESkeletalMeshOptimizationImportance> ShadingImportance; // 0x001B(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ESkeletalMeshOptimizationImportance> SkinningImportance; // 0x001C(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRemapMorphTargets : 1; // 0x001D(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRecalcNormals : 1; // 0x001D(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_PMF3[0x2]; // 0x001E(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float WeldingThreshold; // 0x0020(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NormalsThreshold; // 0x0024(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MaxBonesPerVertex; // 0x0028(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnforceBoneBoundaries : 1; // 0x002C(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_816L[0x3]; // 0x002D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float VolumeImportance; // 0x0030(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLockEdges : 1; // 0x0034(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_W5SR[0x3]; // 0x0035(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int BaseLOD; // 0x0038(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LatentActionInfo
// 0x0018
struct FLatentActionInfo
{
int Linkage; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int UUID; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ExecutionFunction; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UObject* CallbackTarget; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BoneReference
// 0x0010
struct FBoneReference
{
struct FName BoneName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_6FRU[0x8]; // 0x0008(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SkeletalMeshLODInfo
// 0x00A8
struct FSkeletalMeshLODInfo
{
struct FPerPlatformFloat ScreenSize; // 0x0000(0x0004) (Edit, NoDestructor, NativeAccessSpecifierPublic)
float LODHysteresis; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<int> LODMaterialMap; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
struct FSkeletalMeshOptimizationSettings ReductionSettings; // 0x0018(0x003C) (Edit, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_EF7V[0x4]; // 0x0054(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FBoneReference> BonesToRemove; // 0x0058(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FBoneReference> BonesToPrioritize; // 0x0068(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
float WeightOfPrioritization; // 0x0078(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_XY5K[0x4]; // 0x007C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UAnimSequence* BakePose; // 0x0080(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UAnimSequence* BakePoseOverride; // 0x0088(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString SourceImportFilename; // 0x0090(0x0010) (Edit, ZeroConstructor, EditConst, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bHasBeenSimplified : 1; // 0x00A0(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bHasPerLODVertexColors : 1; // 0x00A0(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAllowCPUAccess : 1; // 0x00A0(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportUniformlyDistributedSampling : 1; // 0x00A0(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_L9NI[0x7]; // 0x00A1(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SkeletalMeshClothBuildParams
// 0x0058
struct FSkeletalMeshClothBuildParams
{
TWeakObjectPtr<class UClothingAssetBase> TargetAsset; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int TargetLod; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bRemapParameters; // 0x000C(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_NU2Y[0x3]; // 0x000D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FString AssetName; // 0x0010(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LODIndex; // 0x0020(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int SourceSection; // 0x0024(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bRemoveFromMesh; // 0x0028(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EPDY[0x7]; // 0x0029(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char PhysicsAsset[0x28]; // 0x0030(0x0028) UNKNOWN PROPERTY: SoftObjectProperty Engine.SkeletalMeshClothBuildParams.PhysicsAsset
};
// ScriptStruct Engine.BoneMirrorExport
// 0x0014
struct FBoneMirrorExport
{
struct FName BoneName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName SourceBoneName; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAxis> BoneFlipAxis; // 0x0010(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_U485[0x3]; // 0x0011(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BoneMirrorInfo
// 0x0008
struct FBoneMirrorInfo
{
int SourceIndex; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAxis> BoneFlipAxis; // 0x0004(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_QZM6[0x3]; // 0x0005(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SkeletalMeshComponentClothTickFunction
// 0x0008 (0x0058 - 0x0050)
struct FSkeletalMeshComponentClothTickFunction : public FTickFunction
{
unsigned char UnknownData_SBUG[0x8]; // 0x0050(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SkeletalMeshComponentEndPhysicsTickFunction
// 0x0008 (0x0058 - 0x0050)
struct FSkeletalMeshComponentEndPhysicsTickFunction : public FTickFunction
{
unsigned char UnknownData_X906[0x8]; // 0x0050(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BoneFilter
// 0x000C
struct FBoneFilter
{
bool bExcludeSelf; // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_IPC1[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName BoneName; // 0x0004(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SkeletalMeshLODGroupSettings
// 0x0080
struct FSkeletalMeshLODGroupSettings
{
struct FPerPlatformFloat ScreenSize; // 0x0000(0x0004) (Edit, NoDestructor, NativeAccessSpecifierPublic)
float LODHysteresis; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EBoneFilterActionOption BoneFilterActionOption; // 0x0008(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_R4S8[0x7]; // 0x0009(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FBoneFilter> BoneList; // 0x0010(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FName> BonesToPrioritize; // 0x0020(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
float WeightOfPrioritization; // 0x0030(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_OX8B[0x4]; // 0x0034(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UAnimSequence* BakePose; // 0x0038(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FSkeletalMeshOptimizationSettings ReductionSettings; // 0x0040(0x003C) (Edit, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_D3MR[0x4]; // 0x007C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SkeletalMeshSamplingRegionMaterialFilter
// 0x0008
struct FSkeletalMeshSamplingRegionMaterialFilter
{
struct FName MaterialName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SkeletalMeshSamplingRegionBoneFilter
// 0x000C
struct FSkeletalMeshSamplingRegionBoneFilter
{
struct FName BoneName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIncludeOrExclude : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bApplyToChildren : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_GCF8[0x3]; // 0x0009(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SkeletalMeshSamplingRegion
// 0x0030
struct FSkeletalMeshSamplingRegion
{
struct FName Name; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LODIndex; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportUniformlyDistributedSampling : 1; // 0x000C(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_M92J[0x3]; // 0x000D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FSkeletalMeshSamplingRegionMaterialFilter> MaterialFilters; // 0x0010(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FSkeletalMeshSamplingRegionBoneFilter> BoneFilters; // 0x0020(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SkeletalMeshSamplingLODBuiltData
// 0x0048
struct FSkeletalMeshSamplingLODBuiltData
{
unsigned char UnknownData_PHVN[0x48]; // 0x0000(0x0048) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SkeletalMeshSamplingRegionBuiltData
// 0x0078
struct FSkeletalMeshSamplingRegionBuiltData
{
unsigned char UnknownData_35QY[0x78]; // 0x0000(0x0078) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SkeletalMeshSamplingBuiltData
// 0x0020
struct FSkeletalMeshSamplingBuiltData
{
TArray<struct FSkeletalMeshSamplingLODBuiltData> WholeMeshBuiltData; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FSkeletalMeshSamplingRegionBuiltData> RegionBuiltData; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SkeletalMeshSamplingInfo
// 0x0030
struct FSkeletalMeshSamplingInfo
{
TArray<struct FSkeletalMeshSamplingRegion> Regions; // 0x0000(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
struct FSkeletalMeshSamplingBuiltData BuiltData; // 0x0010(0x0020) (NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.VirtualBone
// 0x0018
struct FVirtualBone
{
struct FName SourceBoneName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName TargetBoneName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName VirtualBoneName; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimSlotGroup
// 0x0018
struct FAnimSlotGroup
{
struct FName GroupName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FName> SlotNames; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NameMapping
// 0x0010
struct FNameMapping
{
struct FName NodeName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName BoneName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RigConfiguration
// 0x0018
struct FRigConfiguration
{
class URig* Rig; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FNameMapping> BoneMappingTable; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ForceFeedbackParameters
// 0x000C
struct FForceFeedbackParameters
{
struct FName Tag; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bLooping; // 0x0008(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bIgnoreTimeDilation; // 0x0009(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bPlayWhilePaused; // 0x000A(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_MMG0[0x1]; // 0x000B(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BoneReductionSetting
// 0x0010
struct FBoneReductionSetting
{
TArray<struct FName> BonesToRemove; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ReferencePose
// 0x0018
struct FReferencePose
{
struct FName PoseName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FTransform> ReferencePose; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BoneNode
// 0x0010
struct FBoneNode
{
struct FName Name; // 0x0000(0x0008) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ParentIndex; // 0x0008(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EBoneTranslationRetargetingMode> TranslationRetargetingMode; // 0x000C(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_L9R2[0x3]; // 0x000D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SkeletonToMeshLinkup
// 0x0020
struct FSkeletonToMeshLinkup
{
TArray<int> SkeletonToMeshTable; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<int> MeshToSkeletonTable; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SkelMeshComponentLODInfo
// 0x0028
struct FSkelMeshComponentLODInfo
{
TArray<bool> HiddenMaterials; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_0K2Z[0x18]; // 0x0010(0x0018) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SkelMeshSkinWeightInfo
// 0x0028
struct FSkelMeshSkinWeightInfo
{
int Bones[0x8]; // 0x0000(0x0020) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char Weights[0x8]; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PerPlatformBool
// 0x0001
struct FPerPlatformBool
{
bool Default; // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PerPlatformInt
// 0x0004
struct FPerPlatformInt
{
int Default; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SkinWeightProfileInfo
// 0x0010
struct FSkinWeightProfileInfo
{
struct FName Name; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FPerPlatformBool DefaultProfile; // 0x0008(0x0001) (Edit, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_9Q0G[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FPerPlatformInt DefaultProfileFromLODIndex; // 0x000C(0x0004) (Edit, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PrecomputedSkyLightInstanceData
// 0x00B8 (0x0160 - 0x00A8)
struct FPrecomputedSkyLightInstanceData : public FSceneComponentInstanceData
{
struct FGuid LightGuid; // 0x00A8(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AverageBrightness; // 0x00B8(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_KEPR[0xA4]; // 0x00BC(0x00A4) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SmartNameContainer
// 0x0050
struct FSmartNameContainer
{
unsigned char UnknownData_CITH[0x50]; // 0x0000(0x0050) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SmartNameMapping
// 0x0060
struct FSmartNameMapping
{
unsigned char UnknownData_CUIH[0x60]; // 0x0000(0x0060) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CurveMetaData
// 0x0020
struct FCurveMetaData
{
unsigned char UnknownData_GCUM[0x20]; // 0x0000(0x0020) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.RichCurveKey
// 0x001C
struct FRichCurveKey
{
TEnumAsByte<ERichCurveInterpMode> InterpMode; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ERichCurveTangentMode> TangentMode; // 0x0001(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ERichCurveTangentWeightMode> TangentWeightMode; // 0x0002(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_YPMT[0x1]; // 0x0003(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float Time; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Value; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ArriveTangent; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ArriveTangentWeight; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LeaveTangent; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LeaveTangentWeight; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RichCurve
// 0x0010 (0x0080 - 0x0070)
struct FRichCurve : public FRealCurve
{
TArray<struct FRichCurveKey> Keys; // 0x0070(0x0010) (Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RuntimeFloatCurve
// 0x0088
struct FRuntimeFloatCurve
{
struct FRichCurve EditorCurveData; // 0x0000(0x0080) (NativeAccessSpecifierPublic)
class UCurveFloat* ExternalCurve; // 0x0080(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BaseAttenuationSettings
// 0x00B0
struct FBaseAttenuationSettings
{
unsigned char UnknownData_OYQJ[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
EAttenuationDistanceModel DistanceAlgorithm; // 0x0008(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAttenuationShape> AttenuationShape; // 0x0009(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EO8H[0x2]; // 0x000A(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float dBAttenuationAtMax; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector AttenuationShapeExtents; // 0x0010(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ConeOffset; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FalloffDistance; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_TJ0B[0x4]; // 0x0024(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FRuntimeFloatCurve CustomAttenuationCurve; // 0x0028(0x0088) (Edit, BlueprintVisible, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundAttenuationPluginSettings
// 0x0030
struct FSoundAttenuationPluginSettings
{
TArray<class USpatializationPluginSourceSettingsBase*> SpatializationPluginSettingsArray; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<class UOcclusionPluginSourceSettingsBase*> OcclusionPluginSettingsArray; // 0x0010(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<class UReverbPluginSourceSettingsBase*> ReverbPluginSettingsArray; // 0x0020(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundAttenuationSettings
// 0x0238 (0x02E8 - 0x00B0)
struct FSoundAttenuationSettings : public FBaseAttenuationSettings
{
unsigned char bAttenuate : 1; // 0x00B0(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSpatialize : 1; // 0x00B0(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAttenuateWithLPF : 1; // 0x00B0(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableListenerFocus : 1; // 0x00B0(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableFocusInterpolation : 1; // 0x00B0(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableOcclusion : 1; // 0x00B0(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseComplexCollisionForOcclusion : 1; // 0x00B0(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableReverbSend : 1; // 0x00B0(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bApplyNormalizationToStereoSounds : 1; // 0x00B1(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableLogFrequencyScaling : 1; // 0x00B1(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ESoundSpatializationAlgorithm> SpatializationAlgorithm; // 0x00B2(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EAirAbsorptionMethod AbsorptionMethod; // 0x00B3(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionChannel> OcclusionTraceChannel; // 0x00B4(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EReverbSendMethod ReverbSendMethod; // 0x00B5(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_XJEX[0x2]; // 0x00B6(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float OmniRadius; // 0x00B8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float StereoSpread; // 0x00BC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPFRadiusMin; // 0x00C0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPFRadiusMax; // 0x00C4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRuntimeFloatCurve CustomLowpassAirAbsorptionCurve; // 0x00C8(0x0088) (Edit, BlueprintVisible, NativeAccessSpecifierPublic)
struct FRuntimeFloatCurve CustomHighpassAirAbsorptionCurve; // 0x0150(0x0088) (Edit, BlueprintVisible, NativeAccessSpecifierPublic)
float LPFFrequencyAtMin; // 0x01D8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LPFFrequencyAtMax; // 0x01DC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HPFFrequencyAtMin; // 0x01E0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HPFFrequencyAtMax; // 0x01E4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FocusAzimuth; // 0x01E8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NonFocusAzimuth; // 0x01EC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FocusDistanceScale; // 0x01F0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NonFocusDistanceScale; // 0x01F4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FocusPriorityScale; // 0x01F8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NonFocusPriorityScale; // 0x01FC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FocusVolumeAttenuation; // 0x0200(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NonFocusVolumeAttenuation; // 0x0204(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FocusAttackInterpSpeed; // 0x0208(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FocusReleaseInterpSpeed; // 0x020C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OcclusionLowPassFilterFrequency; // 0x0210(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OcclusionVolumeAttenuation; // 0x0214(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OcclusionInterpolationTime; // 0x0218(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ReverbWetLevelMin; // 0x021C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ReverbWetLevelMax; // 0x0220(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ReverbDistanceMin; // 0x0224(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ReverbDistanceMax; // 0x0228(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ManualReverbSendLevel; // 0x022C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRuntimeFloatCurve CustomReverbSendCurve; // 0x0230(0x0088) (Edit, BlueprintVisible, NativeAccessSpecifierPublic)
struct FSoundAttenuationPluginSettings PluginSettings; // 0x02B8(0x0030) (Edit, BlueprintVisible, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PassiveSoundMixModifier
// 0x0010
struct FPassiveSoundMixModifier
{
class USoundMix* SoundMix; // 0x0000(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MinVolumeThreshold; // 0x0008(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxVolumeThreshold; // 0x000C(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundClassProperties
// 0x002C
struct FSoundClassProperties
{
float Volume; // 0x0000(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Pitch; // 0x0004(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float StereoBleed; // 0x0008(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LFEBleed; // 0x000C(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float VoiceCenterChannelVolume; // 0x0010(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float RadioFilterVolume; // 0x0014(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float RadioFilterVolumeThreshold; // 0x0018(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bApplyEffects : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAlwaysPlay : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIsUISound : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIsMusic : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bReverb : 1; // 0x001C(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_3JL4[0x3]; // 0x001D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float Default2DReverbSendAmount; // 0x0020(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCenterChannelOnly : 1; // 0x0024(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bApplyAmbientVolumes : 1; // 0x0024(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_O0JD[0x3]; // 0x0025(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<EAudioOutputTarget> OutputTarget; // 0x0028(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_2R0U[0x3]; // 0x0029(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SoundClassEditorData
// 0x0008
struct FSoundClassEditorData
{
unsigned char UnknownData_9QO4[0x8]; // 0x0000(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SoundConcurrencySettings
// 0x0020
struct FSoundConcurrencySettings
{
int MaxCount; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLimitToOwner : 1; // 0x0004(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_UHS6[0x3]; // 0x0005(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<EMaxConcurrentResolutionRule> ResolutionRule; // 0x0008(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ORHI[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float VolumeScale; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
float VolumeScaleAttackTime; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bVolumeScaleCanRelease : 1; // 0x0014(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_C1BQ[0x3]; // 0x0015(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float VolumeScaleReleaseTime; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float VoiceStealReleaseTime; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundNodeEditorData
// 0x0008
struct FSoundNodeEditorData
{
unsigned char UnknownData_3N9K[0x8]; // 0x0000(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SourceEffectChainEntry
// 0x0010
struct FSourceEffectChainEntry
{
class USoundEffectSourcePreset* Preset; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bBypass : 1; // 0x0008(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_SI1O[0x7]; // 0x0009(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SoundGroup
// 0x0020
struct FSoundGroup
{
TEnumAsByte<ESoundGroup> SoundGroup; // 0x0000(0x0001) (ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ERFY[0x7]; // 0x0001(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FString DisplayName; // 0x0008(0x0010) (ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAlwaysDecompressOnLoad : 1; // 0x0018(0x0001) BIT_FIELD (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ONQW[0x3]; // 0x0019(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float DecompressedDuration; // 0x001C(0x0004) (ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundClassAdjuster
// 0x0018
struct FSoundClassAdjuster
{
class USoundClass* SoundClassObject; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float VolumeAdjuster; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PitchAdjuster; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bApplyToChildren : 1; // 0x0010(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_XOID[0x3]; // 0x0011(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float VoiceCenterChannelVolumeAdjuster; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AudioEQEffect
// 0x0038
struct FAudioEQEffect
{
unsigned char UnknownData_46RQ[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float FrequencyCenter0; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Gain0; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bandwidth0; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FrequencyCenter1; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Gain1; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bandwidth1; // 0x001C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FrequencyCenter2; // 0x0020(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Gain2; // 0x0024(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bandwidth2; // 0x0028(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FrequencyCenter3; // 0x002C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Gain3; // 0x0030(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bandwidth3; // 0x0034(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.DistanceDatum
// 0x0014
struct FDistanceDatum
{
float FadeInDistanceStart; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FadeInDistanceEnd; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FadeOutDistanceStart; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FadeOutDistanceEnd; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Volume; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ModulatorContinuousParams
// 0x0020
struct FModulatorContinuousParams
{
struct FName ParameterName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Default; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MinInput; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxInput; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MinOutput; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxOutput; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EModulationParamMode> ParamMode; // 0x001C(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_1IJM[0x3]; // 0x001D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SoundSourceBusSendInfo
// 0x00B0
struct FSoundSourceBusSendInfo
{
ESourceBusSendLevelControlMethod SourceBusSendLevelControlMethod; // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_CC2W[0x7]; // 0x0001(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class USoundSourceBus* SoundSourceBus; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SendLevel; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MinSendLevel; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxSendLevel; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MinSendDistance; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxSendDistance; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Y3JP[0x4]; // 0x0024(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FRuntimeFloatCurve CustomSendLevelCurve; // 0x0028(0x0088) (Edit, BlueprintVisible, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundSubmixSendInfo
// 0x00B0
struct FSoundSubmixSendInfo
{
ESendLevelControlMethod SendLevelControlMethod; // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_SQB0[0x7]; // 0x0001(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class USoundSubmix* SoundSubmix; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SendLevel; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MinSendLevel; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxSendLevel; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MinSendDistance; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxSendDistance; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Y90C[0x4]; // 0x0024(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FRuntimeFloatCurve CustomSendLevelCurve; // 0x0028(0x0088) (Edit, BlueprintVisible, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundWaveEnvelopeTimeData
// 0x0008
struct FSoundWaveEnvelopeTimeData
{
float Amplitude; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TimeSec; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ActorComponentTickFunction
// 0x0008 (0x0058 - 0x0050)
struct FActorComponentTickFunction : public FTickFunction
{
unsigned char UnknownData_C4RA[0x8]; // 0x0050(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SoundWaveSpectralDataEntry
// 0x0008
struct FSoundWaveSpectralDataEntry
{
float Magnitude; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NormalizedMagnitude; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundWaveSpectralTimeData
// 0x0018
struct FSoundWaveSpectralTimeData
{
TArray<struct FSoundWaveSpectralDataEntry> Data; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
float TimeSec; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_AUVY[0x4]; // 0x0014(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SoundWaveEnvelopeDataPerSound
// 0x0010
struct FSoundWaveEnvelopeDataPerSound
{
float Envelope; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PlaybackTime; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class USoundWave* SoundWave; // 0x0008(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundWaveSpectralData
// 0x000C
struct FSoundWaveSpectralData
{
float FrequencyHz; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Magnitude; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NormalizedMagnitude; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SimpleMemberReference
// 0x0020
struct FSimpleMemberReference
{
class UObject* MemberParent; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName MemberName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid MemberGuid; // 0x0010(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundWaveSpectralDataPerSound
// 0x0020
struct FSoundWaveSpectralDataPerSound
{
TArray<struct FSoundWaveSpectralData> SpectralData; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
float PlaybackTime; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_5STK[0x4]; // 0x0014(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class USoundWave* SoundWave; // 0x0018(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StreamedAudioPlatformData
// 0x0020
struct FStreamedAudioPlatformData
{
unsigned char UnknownData_9OMC[0x20]; // 0x0000(0x0020) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SplineCurves
// 0x0068
struct FSplineCurves
{
struct FInterpCurveVector Position; // 0x0000(0x0018) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FInterpCurveQuat Rotation; // 0x0018(0x0018) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FInterpCurveVector Scale; // 0x0030(0x0018) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FInterpCurveFloat ReparamTable; // 0x0048(0x0018) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class USplineMetadata* MetaData; // 0x0060(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SplineInstanceData
// 0x00D8 (0x0180 - 0x00A8)
struct FSplineInstanceData : public FSceneComponentInstanceData
{
bool bSplineHasBeenEdited; // 0x00A8(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ZS9V[0x7]; // 0x00A9(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FSplineCurves SplineCurves; // 0x00B0(0x0068) (NativeAccessSpecifierPublic)
struct FSplineCurves SplineCurvesPreUCS; // 0x0118(0x0068) (NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SplinePoint
// 0x0044
struct FSplinePoint
{
float InputKey; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Position; // 0x0004(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector ArriveTangent; // 0x0010(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector LeaveTangent; // 0x001C(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x0028(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FVector Scale; // 0x0034(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ESplinePointType> Type; // 0x0040(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_T11Q[0x3]; // 0x0041(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SplineMeshInstanceData
// 0x0030 (0x00D8 - 0x00A8)
struct FSplineMeshInstanceData : public FSceneComponentInstanceData
{
struct FVector StartPos; // 0x00A8(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector EndPos; // 0x00B4(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector StartTangent; // 0x00C0(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector EndTangent; // 0x00CC(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SplineMeshParams
// 0x0058
struct FSplineMeshParams
{
struct FVector StartPos; // 0x0000(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector StartTangent; // 0x000C(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D StartScale; // 0x0018(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float StartRoll; // 0x0020(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D StartOffset; // 0x0024(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector EndPos; // 0x002C(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector EndTangent; // 0x0038(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D EndScale; // 0x0044(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float EndRoll; // 0x004C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D EndOffset; // 0x0050(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MaterialRemapIndex
// 0x0018
struct FMaterialRemapIndex
{
uint32_t ImportVersionKey; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_B4UV[0x4]; // 0x0004(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<int> MaterialRemap; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StaticMaterial
// 0x0030
struct FStaticMaterial
{
class UMaterialInterface* MaterialInterface; // 0x0000(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName MaterialSlotName; // 0x0008(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ImportedMaterialSlotName; // 0x0010(0x0008) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FMeshUVChannelInfo UVChannelData; // 0x0018(0x0014) (Edit, BlueprintVisible, BlueprintReadOnly, EditConst, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_OIP0[0x4]; // 0x002C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AssetEditorOrbitCameraPosition
// 0x0028
struct FAssetEditorOrbitCameraPosition
{
bool bIsSet; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_SDJV[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FVector CamOrbitPoint; // 0x0004(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector CamOrbitZoom; // 0x0010(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator CamOrbitRotation; // 0x001C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MeshSectionInfo
// 0x0008
struct FMeshSectionInfo
{
int MaterialIndex; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bEnableCollision; // 0x0004(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bCastShadow; // 0x0005(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_0EHR[0x2]; // 0x0006(0x0002) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MeshSectionInfoMap
// 0x0050
struct FMeshSectionInfoMap
{
TMap<uint32_t, struct FMeshSectionInfo> Map; // 0x0000(0x0050) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MeshBuildSettings
// 0x0030
struct FMeshBuildSettings
{
unsigned char bUseMikkTSpace : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRecomputeNormals : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRecomputeTangents : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRemoveDegenerates : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bBuildAdjacencyBuffer : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bBuildReversedIndexBuffer : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseHighPrecisionTangentBasis : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseFullPrecisionUVs : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGenerateLightmapUVs : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGenerateDistanceFieldAsIfTwoSided : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_B3B4[0x2]; // 0x0002(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int MinLightmapResolution; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int SrcLightmapIndex; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int DstLightmapIndex; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BuildScale; // 0x0010(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector BuildScale3D; // 0x0014(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DistanceFieldResolutionScale; // 0x0020(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_LNBD[0x4]; // 0x0024(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UStaticMesh* DistanceFieldReplacementMesh; // 0x0028(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MeshReductionSettings
// 0x0024
struct FMeshReductionSettings
{
float PercentTriangles; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PercentVertices; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxDeviation; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PixelError; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float WeldingThreshold; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HardAngleThreshold; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int BaseLODModel; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EMeshFeatureImportance> SilhouetteImportance; // 0x001C(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EMeshFeatureImportance> TextureImportance; // 0x001D(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EMeshFeatureImportance> ShadingImportance; // 0x001E(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRecalculateNormals : 1; // 0x001F(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGenerateUniqueLightmapUVs : 1; // 0x001F(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bKeepSymmetry : 1; // 0x001F(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bVisibilityAided : 1; // 0x001F(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCullOccluded : 1; // 0x001F(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EStaticMeshReductionTerimationCriterion TerminationCriterion; // 0x0020(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EMeshFeatureImportance> VisibilityAggressiveness; // 0x0021(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EMeshFeatureImportance> VertexColorImportance; // 0x0022(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_2DHP[0x1]; // 0x0023(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.StaticMeshSourceModel
// 0x0070
struct FStaticMeshSourceModel
{
struct FMeshBuildSettings BuildSettings; // 0x0000(0x0030) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FMeshReductionSettings ReductionSettings; // 0x0030(0x0024) (Edit, NoDestructor, NativeAccessSpecifierPublic)
float LODDistance; // 0x0054(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FPerPlatformFloat ScreenSize; // 0x0058(0x0004) (Edit, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_VC4K[0x4]; // 0x005C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FString SourceImportFilename; // 0x0060(0x0010) (Edit, ZeroConstructor, EditConst, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StaticMeshOptimizationSettings
// 0x001C
struct FStaticMeshOptimizationSettings
{
TEnumAsByte<EOptimizationType> ReductionMethod; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_HAI2[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float NumOfTrianglesPercentage; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxDeviationPercentage; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float WeldingThreshold; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bRecalcNormals; // 0x0010(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_D1FW[0x3]; // 0x0011(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float NormalsThreshold; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char SilhouetteImportance; // 0x0018(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char TextureImportance; // 0x0019(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char ShadingImportance; // 0x001A(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_QGQM[0x1]; // 0x001B(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PaintedVertex
// 0x0020
struct FPaintedVertex
{
struct FVector Position; // 0x0000(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FColor Color; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector4 Normal; // 0x0010(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StaticMeshVertexColorLODData
// 0x0028
struct FStaticMeshVertexColorLODData
{
TArray<struct FPaintedVertex> PaintedVertices; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FColor> VertexBufferColors; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
uint32_t LODIndex; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_E0KP[0x4]; // 0x0024(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.StreamingTextureBuildInfo
// 0x000C
struct FStreamingTextureBuildInfo
{
uint32_t PackedRelativeBox; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int TextureLevelIndex; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TexelFactor; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StaticMeshComponentInstanceData
// 0x0040 (0x0130 - 0x00F0)
struct FStaticMeshComponentInstanceData : public FPrimitiveComponentInstanceData
{
class UStaticMesh* StaticMesh; // 0x00F0(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FStaticMeshVertexColorLODData> VertexColorLODs; // 0x00F8(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FGuid> CachedStaticLighting; // 0x0108(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FStreamingTextureBuildInfo> StreamingTextureData; // 0x0118(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_5OOJ[0x8]; // 0x0128(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.StaticMeshComponentLODInfo
// 0x00A8
struct FStaticMeshComponentLODInfo
{
unsigned char UnknownData_XONE[0xA8]; // 0x0000(0x00A8) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MaterialParameterInfo
// 0x0010
struct FMaterialParameterInfo
{
struct FName Name; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EMaterialParameterAssociation> Association; // 0x0008(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_6Y9B[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int Index; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StaticSwitchParameter
// 0x0024
struct FStaticSwitchParameter
{
struct FMaterialParameterInfo ParameterInfo; // 0x0000(0x0010) (NoDestructor, NativeAccessSpecifierPublic)
bool Value; // 0x0010(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bOverride; // 0x0011(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_224L[0x2]; // 0x0012(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FGuid ExpressionGUID; // 0x0014(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StaticComponentMaskParameter
// 0x0028
struct FStaticComponentMaskParameter
{
struct FMaterialParameterInfo ParameterInfo; // 0x0000(0x0010) (NoDestructor, NativeAccessSpecifierPublic)
bool R; // 0x0010(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool G; // 0x0011(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool B; // 0x0012(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool A; // 0x0013(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bOverride; // 0x0014(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_WSYS[0x3]; // 0x0015(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FGuid ExpressionGUID; // 0x0018(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StaticTerrainLayerWeightParameter
// 0x002C
struct FStaticTerrainLayerWeightParameter
{
struct FMaterialParameterInfo ParameterInfo; // 0x0000(0x0010) (NoDestructor, NativeAccessSpecifierPublic)
bool bOverride; // 0x0010(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VU9W[0x3]; // 0x0011(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FGuid ExpressionGUID; // 0x0014(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int WeightmapIndex; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bWeightBasedBlend; // 0x0028(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_85VQ[0x3]; // 0x0029(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MaterialLayersFunctions
// 0x0040
struct FMaterialLayersFunctions
{
TArray<class UMaterialFunctionInterface*> Layers; // 0x0000(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<class UMaterialFunctionInterface*> Blends; // 0x0010(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<bool> LayerStates; // 0x0020(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
struct FString KeyString; // 0x0030(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StaticMaterialLayersParameter
// 0x0068
struct FStaticMaterialLayersParameter
{
struct FMaterialParameterInfo ParameterInfo; // 0x0000(0x0010) (NoDestructor, NativeAccessSpecifierPublic)
struct FMaterialLayersFunctions Value; // 0x0010(0x0040) (NativeAccessSpecifierPublic)
bool bOverride; // 0x0050(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_BBDE[0x3]; // 0x0051(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FGuid ExpressionGUID; // 0x0054(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_MVTF[0x4]; // 0x0064(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.StaticParameterSet
// 0x0040
struct FStaticParameterSet
{
TArray<struct FStaticSwitchParameter> StaticSwitchParameters; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FStaticComponentMaskParameter> StaticComponentMaskParameters; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FStaticTerrainLayerWeightParameter> TerrainLayerWeightParameters; // 0x0020(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FStaticMaterialLayersParameter> MaterialLayersParameters; // 0x0030(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StringCurveKey
// 0x0018
struct FStringCurveKey
{
float Time; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_5GXG[0x4]; // 0x0004(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FString Value; // 0x0008(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StringCurve
// 0x0020 (0x0088 - 0x0068)
struct FStringCurve : public FIndexedCurve
{
struct FString DefaultValue; // 0x0068(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FStringCurveKey> Keys; // 0x0078(0x0010) (Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SubsurfaceProfileStruct
// 0x0050
struct FSubsurfaceProfileStruct
{
float ScatterRadius; // 0x0000(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor SubsurfaceColor; // 0x0004(0x0010) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor FalloffColor; // 0x0014(0x0010) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor BoundaryColorBleed; // 0x0024(0x0010) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ExtinctionScale; // 0x0034(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NormalScale; // 0x0038(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ScatteringDistribution; // 0x003C(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float IOR; // 0x0040(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Roughness0; // 0x0044(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Roughness1; // 0x0048(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LobeMix; // 0x004C(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TextureFormatSettings
// 0x0002
struct FTextureFormatSettings
{
TEnumAsByte<ETextureCompressionSettings> CompressionSettings; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char CompressionNoAlpha : 1; // 0x0001(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char CompressionNone : 1; // 0x0001(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char SRGB : 1; // 0x0001(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TexturePlatformData
// 0x0028
struct FTexturePlatformData
{
unsigned char UnknownData_LL1D[0x28]; // 0x0000(0x0028) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TextureSource
// 0x00A0
struct FTextureSource
{
unsigned char UnknownData_S1RI[0xA0]; // 0x0000(0x00A0) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TextureSourceBlock
// 0x0018
struct FTextureSourceBlock
{
int BlockX; // 0x0000(0x0004) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int BlockY; // 0x0004(0x0004) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int SizeX; // 0x0008(0x0004) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int SizeY; // 0x000C(0x0004) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int NumSlices; // 0x0010(0x0004) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int NumMips; // 0x0014(0x0004) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TextureLODGroup
// 0x0054
struct FTextureLODGroup
{
TEnumAsByte<ETextureGroup> Group; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_F320[0xB]; // 0x0001(0x000B) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int LODBias; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LODBias_Smaller; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LODBias_Smallest; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_K5DL[0x4]; // 0x0018(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int NumStreamedMips; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ETextureMipGenSettings> MipGenSettings; // 0x0020(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_O2L2[0x3]; // 0x0021(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int MinLODSize; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MaxLODSize; // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MaxLODSize_Smaller; // 0x002C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MaxLODSize_Smallest; // 0x0030(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int OptionalLODBias; // 0x0034(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int OptionalMaxLODSize; // 0x0038(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_26D5[0x4]; // 0x003C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName MinMagFilter; // 0x0040(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName MipFilter; // 0x0048(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
ETextureMipLoadOptions MipLoadOptions; // 0x0050(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_V4ZH[0x3]; // 0x0051(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.StreamingRenderAssetPrimitiveInfo
// 0x0030
struct FStreamingRenderAssetPrimitiveInfo
{
class UStreamableRenderAsset* RenderAsset; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FBoxSphereBounds Bounds; // 0x0008(0x001C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
float TexelFactor; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint32_t PackedRelativeBox; // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAllowInvalidTexelFactorWhenUnregistered : 1; // 0x002C(0x0001) BIT_FIELD (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_IYQQ[0x3]; // 0x002D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TimelineEventEntry
// 0x0014
struct FTimelineEventEntry
{
float Time; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FScriptDelegate EventFunc; // 0x0004(0x0010) (ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TimelineVectorTrack
// 0x0040
struct FTimelineVectorTrack
{
class UCurveVector* VectorCurve; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FScriptDelegate InterpFunc; // 0x0008(0x0010) (ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
struct FName TrackName; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName VectorPropertyName; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UStructProperty* VectorProperty; // 0x0028(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_25DG[0x10]; // 0x0030(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TimelineFloatTrack
// 0x0040
struct FTimelineFloatTrack
{
class UCurveFloat* FloatCurve; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FScriptDelegate InterpFunc; // 0x0008(0x0010) (ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
struct FName TrackName; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName FloatPropertyName; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UFloatProperty* FloatProperty; // 0x0028(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_NNLH[0x10]; // 0x0030(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TimelineLinearColorTrack
// 0x0040
struct FTimelineLinearColorTrack
{
class UCurveLinearColor* LinearColorCurve; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FScriptDelegate InterpFunc; // 0x0008(0x0010) (ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
struct FName TrackName; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName LinearColorPropertyName; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UStructProperty* LinearColorProperty; // 0x0028(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_IM3R[0x10]; // 0x0030(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.Timeline
// 0x0098
struct FTimeline
{
TEnumAsByte<ETimelineLengthMode> LengthMode; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, RepSkip, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char bLooping : 1; // 0x0001(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char bReversePlayback : 1; // 0x0001(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char bPlaying : 1; // 0x0001(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_44OO[0x2]; // 0x0002(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float Length; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, RepSkip, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
float PlayRate; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
float Position; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
TArray<struct FTimelineEventEntry> Events; // 0x0010(0x0010) (ZeroConstructor, RepSkip, ContainsInstancedReference, NativeAccessSpecifierPrivate)
TArray<struct FTimelineVectorTrack> InterpVectors; // 0x0020(0x0010) (ZeroConstructor, RepSkip, ContainsInstancedReference, NativeAccessSpecifierPrivate)
TArray<struct FTimelineFloatTrack> InterpFloats; // 0x0030(0x0010) (ZeroConstructor, RepSkip, ContainsInstancedReference, NativeAccessSpecifierPrivate)
TArray<struct FTimelineLinearColorTrack> InterpLinearColors; // 0x0040(0x0010) (ZeroConstructor, RepSkip, ContainsInstancedReference, NativeAccessSpecifierPrivate)
struct FScriptDelegate TimelinePostUpdateFunc; // 0x0050(0x0010) (ZeroConstructor, InstancedReference, RepSkip, NoDestructor, NativeAccessSpecifierPrivate)
struct FScriptDelegate TimelineFinishedFunc; // 0x0060(0x0010) (ZeroConstructor, InstancedReference, RepSkip, NoDestructor, NativeAccessSpecifierPrivate)
TWeakObjectPtr<class UObject> PropertySetObject; // 0x0070(0x0008) (ZeroConstructor, IsPlainOldData, RepSkip, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
struct FName DirectionPropertyName; // 0x0078(0x0008) (ZeroConstructor, IsPlainOldData, RepSkip, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_H6SX[0x10]; // 0x0080(0x0010) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UProperty* DirectionProperty; // 0x0090(0x0008) (ZeroConstructor, Transient, IsPlainOldData, RepSkip, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.TTTrackBase
// 0x0018
struct FTTTrackBase
{
unsigned char UnknownData_CKAQ[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName TrackName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
bool bIsExternalCurve; // 0x0010(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_NM52[0x7]; // 0x0011(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TTPropertyTrack
// 0x0008 (0x0020 - 0x0018)
struct FTTPropertyTrack : public FTTTrackBase
{
struct FName PropertyName; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.TTLinearColorTrack
// 0x0008 (0x0028 - 0x0020)
struct FTTLinearColorTrack : public FTTPropertyTrack
{
class UCurveLinearColor* CurveLinearColor; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TTVectorTrack
// 0x0008 (0x0028 - 0x0020)
struct FTTVectorTrack : public FTTPropertyTrack
{
class UCurveVector* CurveVector; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TTFloatTrack
// 0x0008 (0x0028 - 0x0020)
struct FTTFloatTrack : public FTTPropertyTrack
{
class UCurveFloat* CurveFloat; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TTEventTrack
// 0x0010 (0x0028 - 0x0018)
struct FTTEventTrack : public FTTTrackBase
{
struct FName FunctionName; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UCurveFloat* CurveKeys; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TimeStretchCurveInstance
// 0x0030
struct FTimeStretchCurveInstance
{
bool bHasValidData; // 0x0000(0x0001) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_7MVA[0x2F]; // 0x0001(0x002F) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TimeStretchCurveMarker
// 0x0010
struct FTimeStretchCurveMarker
{
float Time[0x3]; // 0x0000(0x000C) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Alpha; // 0x000C(0x0004) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TimeStretchCurve
// 0x0028
struct FTimeStretchCurve
{
float SamplingRate; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
float CurveValueMinPrecision; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
TArray<struct FTimeStretchCurveMarker> Markers; // 0x0008(0x0010) (Edit, ZeroConstructor, EditConst, NativeAccessSpecifierPrivate)
float Sum_dT_i_by_C_i[0x3]; // 0x0018(0x000C) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_T9SA[0x4]; // 0x0024(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TouchInputControl
// 0x0068
struct FTouchInputControl
{
class UTexture2D* Image1; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UTexture2D* Image2; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D Center; // 0x0010(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D VisualSize; // 0x0018(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D ThumbSize; // 0x0020(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D InteractionSize; // 0x0028(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D InputScale; // 0x0030(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FKey MainInputKey; // 0x0038(0x0018) (Edit, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FKey AltInputKey; // 0x0050(0x0018) (Edit, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.HardwareCursorReference
// 0x0010
struct FHardwareCursorReference
{
struct FName CursorPath; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D HotSpot; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.VirtualTextureSpacePoolConfig
// 0x000C
struct FVirtualTextureSpacePoolConfig
{
int SizeInMegabyte; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int TileSize; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EPixelFormat> Format; // 0x0008(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_OCKZ[0x3]; // 0x0009(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.VoiceSettings
// 0x0018
struct FVoiceSettings
{
class USceneComponent* ComponentToAttachTo; // 0x0000(0x0008) (Edit, BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class USoundAttenuation* AttenuationSettings; // 0x0008(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class USoundEffectSourcePresetChain* SourceEffectChain; // 0x0010(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LevelStreamingWrapper
// 0x0008
struct FLevelStreamingWrapper
{
class ULevelStreaming* StreamingLevel; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.StreamingLevelsToConsider
// 0x0028
struct FStreamingLevelsToConsider
{
TArray<struct FLevelStreamingWrapper> StreamingLevels; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_DH0D[0x18]; // 0x0010(0x0018) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LevelCollection
// 0x0078
struct FLevelCollection
{
unsigned char UnknownData_7DJT[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class AGameStateBase* GameState; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UNetDriver* NetDriver; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UDemoNetDriver* DemoNetDriver; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class ULevel* PersistentLevel; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char Levels[0x50]; // 0x0028(0x0050) UNKNOWN PROPERTY: SetProperty Engine.LevelCollection.Levels
};
// ScriptStruct Engine.EndPhysicsTickFunction
// 0x0008 (0x0058 - 0x0050)
struct FEndPhysicsTickFunction : public FTickFunction
{
unsigned char UnknownData_UFYR[0x8]; // 0x0050(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.StartPhysicsTickFunction
// 0x0008 (0x0058 - 0x0050)
struct FStartPhysicsTickFunction : public FTickFunction
{
unsigned char UnknownData_2CYU[0x8]; // 0x0050(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LevelViewportInfo
// 0x0020
struct FLevelViewportInfo
{
struct FVector CamPosition; // 0x0000(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator CamRotation; // 0x000C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
float CamOrthoZoom; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool CamUpdated; // 0x001C(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_869C[0x3]; // 0x001D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PSCPoolElem
// 0x0010
struct FPSCPoolElem
{
class UParticleSystemComponent* PSC; // 0x0000(0x0008) (ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_49JJ[0x8]; // 0x0008(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PSCPool
// 0x0038
struct FPSCPool
{
TArray<struct FPSCPoolElem> FreeElements; // 0x0000(0x0010) (ZeroConstructor, Transient, ContainsInstancedReference, NativeAccessSpecifierPublic)
TArray<class UParticleSystemComponent*> InUseComponents_Auto; // 0x0010(0x0010) (ExportObject, ZeroConstructor, Transient, ContainsInstancedReference, NativeAccessSpecifierPublic)
TArray<class UParticleSystemComponent*> InUseComponents_Manual; // 0x0020(0x0010) (ExportObject, ZeroConstructor, Transient, ContainsInstancedReference, NativeAccessSpecifierPublic)
unsigned char UnknownData_MDSA[0x8]; // 0x0030(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.WorldPSCPool
// 0x0058
struct FWorldPSCPool
{
TMap<class UParticleSystem*, struct FPSCPool> WorldParticleSystemPools; // 0x0000(0x0050) (ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)
unsigned char UnknownData_92TJ[0x8]; // 0x0050(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.FastArraySerializerItem
// 0x000C
struct FFastArraySerializerItem
{
int ReplicationID; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, RepSkip, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ReplicationKey; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, RepSkip, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MostRecentArrayReplicationKey; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, RepSkip, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BroadphaseSettings
// 0x0040
struct FBroadphaseSettings
{
bool bUseMBPOnClient; // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bUseMBPOnServer; // 0x0001(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bUseMBPOuterBounds; // 0x0002(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_CLL4[0x1]; // 0x0003(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FBox MBPBounds; // 0x0004(0x001C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FBox MBPOuterBounds; // 0x0020(0x001C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
uint32_t MBPNumSubdivs; // 0x003C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CurveTableRowHandle
// 0x0010
struct FCurveTableRowHandle
{
class UCurveTable* CurveTable; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName RowName; // 0x0008(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FastArraySerializer
// 0x0108
struct FFastArraySerializer
{
unsigned char UnknownData_1JON[0x54]; // 0x0000(0x0054) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int ArrayReplicationKey; // 0x0054(0x0004) (ZeroConstructor, IsPlainOldData, RepSkip, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VUO5[0xA8]; // 0x0058(0x00A8) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
EFastArraySerializerDeltaFlags DeltaFlags; // 0x0100(0x0001) (ZeroConstructor, IsPlainOldData, RepSkip, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_O9Z0[0x7]; // 0x0101(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_Base
// 0x0010
struct FAnimNode_Base
{
unsigned char UnknownData_BSJ7[0x10]; // 0x0000(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.InputRange
// 0x0008
struct FInputRange
{
float Min; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Max; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InputScaleBiasClamp
// 0x0030
struct FInputScaleBiasClamp
{
bool bMapRange; // 0x0000(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bClampResult; // 0x0001(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bInterpResult; // 0x0002(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_RUUO[0x1]; // 0x0003(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FInputRange InRange; // 0x0004(0x0008) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
struct FInputRange OutRange; // 0x000C(0x0008) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
float Scale; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bias; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ClampMin; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ClampMax; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float InterpSpeedIncreasing; // 0x0024(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float InterpSpeedDecreasing; // 0x0028(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_897B[0x4]; // 0x002C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AlphaBlend
// 0x0030
struct FAlphaBlend
{
class UCurveFloat* CustomCurve; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
float BlendTime; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_2D90[0x18]; // 0x000C(0x0018) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
EAlphaBlendOption BlendOption; // 0x0024(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_OGXI[0xB]; // 0x0025(0x000B) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.InputAlphaBoolBlend
// 0x0048
struct FInputAlphaBoolBlend
{
float BlendInTime; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float blendOutTime; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EAlphaBlendOption BlendOption; // 0x0008(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bInitialized; // 0x0009(0x0001) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_SX4K[0x6]; // 0x000A(0x0006) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UCurveFloat* CustomCurve; // 0x0010(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FAlphaBlend AlphaBlend; // 0x0018(0x0030) (Transient, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InputScaleBias
// 0x0008
struct FInputScaleBias
{
float Scale; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Bias; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PoseLinkBase
// 0x0010
struct FPoseLinkBase
{
int LinkID; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_YHBL[0xC]; // 0x0004(0x000C) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ComponentSpacePoseLink
// 0x0000 (0x0010 - 0x0010)
struct FComponentSpacePoseLink : public FPoseLinkBase
{
};
// ScriptStruct Engine.TableRowBase
// 0x0008
struct FTableRowBase
{
unsigned char UnknownData_1KOZ[0x8]; // 0x0000(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimInstanceProxy
// 0x06D0
struct FAnimInstanceProxy
{
unsigned char UnknownData_D25A[0x6D0]; // 0x0000(0x06D0) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.DataTableRowHandle
// 0x0010
struct FDataTableRowHandle
{
class UDataTable* DataTable; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName RowName; // 0x0008(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MaterialProxySettings
// 0x0074
struct FMaterialProxySettings
{
struct FIntPoint TextureSize; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float GutterSpace; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MetallicConstant; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float RoughnessConstant; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SpecularConstant; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OpacityConstant; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OpacityMaskConstant; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AmbientOcclusionConstant; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ETextureSizingType> TextureSizingType; // 0x0024(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EMaterialMergeType> MaterialMergeType; // 0x0025(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EBlendMode> BlendMode; // 0x0026(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAllowTwoSidedMaterial : 1; // 0x0027(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bNormalMap : 1; // 0x0027(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bMetallicMap : 1; // 0x0027(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRoughnessMap : 1; // 0x0027(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSpecularMap : 1; // 0x0027(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEmissiveMap : 1; // 0x0027(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOpacityMap : 1; // 0x0027(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOpacityMaskMap : 1; // 0x0027(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAmbientOcclusionMap : 1; // 0x0028(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_BX77[0x3]; // 0x0029(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FIntPoint DiffuseTextureSize; // 0x002C(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FIntPoint NormalTextureSize; // 0x0034(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FIntPoint MetallicTextureSize; // 0x003C(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FIntPoint RoughnessTextureSize; // 0x0044(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FIntPoint SpecularTextureSize; // 0x004C(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FIntPoint EmissiveTextureSize; // 0x0054(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FIntPoint OpacityTextureSize; // 0x005C(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FIntPoint OpacityMaskTextureSize; // 0x0064(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FIntPoint AmbientOcclusionTextureSize; // 0x006C(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FilePath
// 0x0010
struct FFilePath
{
struct FString FilePath; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.KeyHandleLookupTable
// 0x0060
struct FKeyHandleLookupTable
{
unsigned char UnknownData_STSK[0x60]; // 0x0000(0x0060) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_AssetPlayerBase
// 0x0020 (0x0030 - 0x0010)
struct FAnimNode_AssetPlayerBase : public FAnimNode_Base
{
int GroupIndex; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAnimGroupRole> GroupRole; // 0x0014(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bIgnoreForRelevancyTest; // 0x0015(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_CLS1[0x2]; // 0x0016(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float BlendWeight; // 0x0018(0x0004) (BlueprintVisible, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float InternalTimeAccumulator; // 0x001C(0x0004) (BlueprintVisible, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
unsigned char UnknownData_G51N[0x10]; // 0x0020(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PoseLink
// 0x0000 (0x0010 - 0x0010)
struct FPoseLink : public FPoseLinkBase
{
};
// ScriptStruct Engine.PerBoneBlendWeight
// 0x0008
struct FPerBoneBlendWeight
{
int SourceIndex; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BlendWeight; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BranchFilter
// 0x000C
struct FBranchFilter
{
struct FName BoneName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int BlendDepth; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InputBlendPose
// 0x0010
struct FInputBlendPose
{
TArray<struct FBranchFilter> BranchFilters; // 0x0000(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MeshProxySettings
// 0x0094
struct FMeshProxySettings
{
int ScreenSize; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float VoxelSize; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FMaterialProxySettings MaterialSettings; // 0x0008(0x0074) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
float MergeDistance; // 0x007C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FColor UnresolvedGeometryColor; // 0x0080(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxRayCastDist; // 0x0084(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HardAngleThreshold; // 0x0088(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LightMapResolution; // 0x008C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EProxyNormalComputationMethod> NormalCalculationMethod; // 0x0090(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ELandscapeCullingPrecision> LandscapeCullingPrecision; // 0x0091(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCalculateCorrectLODModel : 1; // 0x0092(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverrideVoxelSize : 1; // 0x0092(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverrideTransferDistance : 1; // 0x0092(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseHardAngleThreshold : 1; // 0x0092(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bComputeLightMapResolution : 1; // 0x0092(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRecalculateNormals : 1; // 0x0092(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseLandscapeCulling : 1; // 0x0092(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAllowAdjacency : 1; // 0x0092(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAllowDistanceField : 1; // 0x0093(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bReuseMeshLightmapUVs : 1; // 0x0093(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCreateCollision : 1; // 0x0093(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAllowVertexColors : 1; // 0x0093(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGenerateLightmapUVs : 1; // 0x0093(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PoseSnapshot
// 0x0038
struct FPoseSnapshot
{
TArray<struct FTransform> LocalTransforms; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FName> BoneNames; // 0x0010(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
struct FName SkeletalMeshName; // 0x0020(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName SnapshotName; // 0x0028(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bIsValid; // 0x0030(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Q4Z1[0x7]; // 0x0031(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_Root
// 0x0020 (0x0030 - 0x0010)
struct FAnimNode_Root : public FAnimNode_Base
{
struct FPoseLink Result; // 0x0010(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
struct FName Name; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName Group; // 0x0028(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimCurveParam
// 0x000C
struct FAnimCurveParam
{
struct FName Name; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_8WKS[0x4]; // 0x0008(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.DirectoryPath
// 0x0010
struct FDirectoryPath
{
struct FString Path; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MeshMergingSettings
// 0x008C
struct FMeshMergingSettings
{
int TargetLightMapResolution; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EUVOutput OutputUVs[0x8]; // 0x0004(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FMaterialProxySettings MaterialSettings; // 0x000C(0x0074) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
int GutterSize; // 0x0080(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int SpecificLOD; // 0x0084(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EMeshLODSelectionType LODSelectionType; // 0x0088(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGenerateLightMapUV : 1; // 0x0089(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bComputedLightMapResolution : 1; // 0x0089(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bPivotPointAtZero : 1; // 0x0089(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bMergePhysicsData : 1; // 0x0089(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bMergeMaterials : 1; // 0x0089(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bBakeVertexDataToMesh : 1; // 0x0089(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseVertexDataForBakingMaterial : 1; // 0x0089(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseTextureBinning : 1; // 0x0089(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bReuseMeshLightmapUVs : 1; // 0x008A(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bMergeEquivalentMaterials : 1; // 0x008A(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseLandscapeCulling : 1; // 0x008A(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIncludeImposters : 1; // 0x008A(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAllowDistanceField : 1; // 0x008A(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_YKWW[0x1]; // 0x008B(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.KShapeElem
// 0x0030
struct FKShapeElem
{
unsigned char UnknownData_KXHR[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float RestOffset; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName Name; // 0x000C(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_1QIH[0x4]; // 0x0014(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bContributeToMass : 1; // 0x0018(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_GGGF[0x17]; // 0x0019(0x0017) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.KSphereElem
// 0x0010 (0x0040 - 0x0030)
struct FKSphereElem : public FKShapeElem
{
struct FVector Center; // 0x0030(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Radius; // 0x003C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.HierarchicalSimplification
// 0x0138
struct FHierarchicalSimplification
{
float TransitionScreenSize; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OverrideDrawDistance; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseOverrideDrawDistance : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAllowSpecificExclusion : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSimplifyMesh : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOnlyGenerateClustersForVolumes : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bReusePreviousLevelClusters : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Y1JP[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FMeshProxySettings ProxySetting; // 0x000C(0x0094) (Edit, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
struct FMeshMergingSettings MergeSetting; // 0x00A0(0x008C) (Edit, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
float DesiredBoundRadius; // 0x012C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DesiredFillingPercentage; // 0x0130(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MinNumberOfActorsToBuild; // 0x0134(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.KBoxElem
// 0x0028 (0x0058 - 0x0030)
struct FKBoxElem : public FKShapeElem
{
struct FVector Center; // 0x0030(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x003C(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
float X; // 0x0048(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Y; // 0x004C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Z; // 0x0050(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_2XSH[0x4]; // 0x0054(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.NetViewer
// 0x0030
struct FNetViewer
{
class UNetConnection* Connection; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class AActor* InViewer; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class AActor* ViewTarget; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector ViewLocation; // 0x0018(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector ViewDir; // 0x0024(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.KSphylElem
// 0x0020 (0x0050 - 0x0030)
struct FKSphylElem : public FKShapeElem
{
struct FVector Center; // 0x0030(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x003C(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
float Radius; // 0x0048(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Length; // 0x004C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.KConvexElem
// 0x0070 (0x00A0 - 0x0030)
struct FKConvexElem : public FKShapeElem
{
TArray<struct FVector> VertexData; // 0x0030(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
struct FBox ElemBox; // 0x0040(0x001C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_NPJI[0x4]; // 0x005C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FTransform Transform; // 0x0060(0x0030) (IsPlainOldData, NoDestructor, NativeAccessSpecifierPrivate)
unsigned char UnknownData_669P[0x10]; // 0x0090(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LightmassWorldInfoSettings
// 0x004C
struct FLightmassWorldInfoSettings
{
float StaticLightingLevelScale; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int NumIndirectLightingBounces; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int NumSkyLightingBounces; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float IndirectLightingQuality; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float IndirectLightingSmoothness; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FColor EnvironmentColor; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float EnvironmentIntensity; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float EmissiveBoost; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DiffuseBoost; // 0x0020(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EVolumeLightingMethod> VolumeLightingMethod; // 0x0024(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseAmbientOcclusion : 1; // 0x0025(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGenerateAmbientOcclusionMaterialMask : 1; // 0x0025(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bVisualizeMaterialDiffuse : 1; // 0x0025(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bVisualizeAmbientOcclusion : 1; // 0x0025(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCompressLightmaps : 1; // 0x0025(0x0001) BIT_FIELD (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_DAA0[0x2]; // 0x0026(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float VolumetricLightmapDetailCellSize; // 0x0028(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float VolumetricLightmapMaximumBrickMemoryMb; // 0x002C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float VolumetricLightmapSphericalHarmonicSmoothing; // 0x0030(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float VolumeLightSamplePlacementScale; // 0x0034(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DirectIlluminationOcclusionFraction; // 0x0038(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float IndirectIlluminationOcclusionFraction; // 0x003C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OcclusionExponent; // 0x0040(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FullyOccludedSamplesFraction; // 0x0044(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxOcclusionDistance; // 0x0048(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.KTaperedCapsuleElem
// 0x0028 (0x0058 - 0x0030)
struct FKTaperedCapsuleElem : public FKShapeElem
{
struct FVector Center; // 0x0030(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x003C(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
float Radius0; // 0x0048(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Radius1; // 0x004C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Length; // 0x0050(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_XTGK[0x4]; // 0x0054(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.KAggregateGeom
// 0x0058
struct FKAggregateGeom
{
TArray<struct FKSphereElem> SphereElems; // 0x0000(0x0010) (Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FKBoxElem> BoxElems; // 0x0010(0x0010) (Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FKSphylElem> SphylElems; // 0x0020(0x0010) (Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FKConvexElem> ConvexElems; // 0x0030(0x0010) (Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FKTaperedCapsuleElem> TaperedCapsuleElems; // 0x0040(0x0010) (Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_YUDG[0x8]; // 0x0050(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimationGroupReference
// 0x000C
struct FAnimationGroupReference
{
struct FName GroupName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAnimGroupRole> GroupRole; // 0x0008(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_M40B[0x3]; // 0x0009(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimGroupInstance
// 0x0070
struct FAnimGroupInstance
{
unsigned char UnknownData_2PU2[0x70]; // 0x0000(0x0070) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimTickRecord
// 0x0048
struct FAnimTickRecord
{
class UAnimationAsset* SourceAsset; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_CCHW[0x40]; // 0x0008(0x0040) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MarkerSyncAnimPosition
// 0x0014
struct FMarkerSyncAnimPosition
{
struct FName PreviousMarkerName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName NextMarkerName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PositionBetweenMarkers; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BlendFilter
// 0x0078
struct FBlendFilter
{
unsigned char UnknownData_9241[0x78]; // 0x0000(0x0078) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BlendSampleData
// 0x0040
struct FBlendSampleData
{
int SampleDataIndex; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_78I1[0x4]; // 0x0004(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UAnimSequence* Animation; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TotalWeight; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Time; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PreviousTime; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SamplePlayRate; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_13L1[0x20]; // 0x0020(0x0020) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimationRecordingSettings
// 0x0010
struct FAnimationRecordingSettings
{
bool bRecordInWorldSpace; // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bRemoveRootAnimation; // 0x0001(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAutoSaveAsset; // 0x0002(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_W1UR[0x1]; // 0x0003(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float SampleRate; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Length; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ERichCurveInterpMode> InterpMode; // 0x000C(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ERichCurveTangentMode> TangentMode; // 0x000D(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_LKQZ[0x2]; // 0x000E(0x0002) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ComponentSpacePose
// 0x0020
struct FComponentSpacePose
{
TArray<struct FTransform> Transforms; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FName> Names; // 0x0010(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LocalSpacePose
// 0x0020
struct FLocalSpacePose
{
TArray<struct FTransform> Transforms; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FName> Names; // 0x0010(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NamedTransform
// 0x0040
struct FNamedTransform
{
struct FTransform Value; // 0x0000(0x0030) (Edit, BlueprintVisible, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FName Name; // 0x0030(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_AZ16[0x8]; // 0x0038(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.NamedColor
// 0x000C
struct FNamedColor
{
struct FColor Value; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName Name; // 0x0004(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NamedVector
// 0x0014
struct FNamedVector
{
struct FVector Value; // 0x0000(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName Name; // 0x000C(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NamedFloat
// 0x000C
struct FNamedFloat
{
float Value; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName Name; // 0x0004(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimParentNodeAssetOverride
// 0x0018
struct FAnimParentNodeAssetOverride
{
class UAnimationAsset* NewAsset; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid ParentNodeGuid; // 0x0008(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimGroupInfo
// 0x0018
struct FAnimGroupInfo
{
struct FName Name; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Color; // 0x0008(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimBlueprintDebugData
// 0x0001
struct FAnimBlueprintDebugData
{
unsigned char UnknownData_70NZ[0x1]; // 0x0000(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimationFrameSnapshot
// 0x0001
struct FAnimationFrameSnapshot
{
unsigned char UnknownData_4T9Z[0x1]; // 0x0000(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.StateMachineDebugData
// 0x00B0
struct FStateMachineDebugData
{
unsigned char UnknownData_2OVI[0xB0]; // 0x0000(0x00B0) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CachedPoseIndices
// 0x0010
struct FCachedPoseIndices
{
TArray<int> OrderedSavedPoseNodeIndices; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimBlueprintFunction
// 0x0068
struct FAnimBlueprintFunction
{
struct FName Name; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName Group; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int OutputPoseNodeIndex; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_0VPM[0x4]; // 0x0014(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FName> InputPoseNames; // 0x0018(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<int> InputPoseNodeIndices; // 0x0028(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
class UStructProperty* OutputPoseNodeProperty; // 0x0038(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<class UStructProperty*> InputPoseNodeProperties; // 0x0040(0x0010) (ZeroConstructor, Transient, NativeAccessSpecifierPublic)
TArray<class UProperty*> InputProperties; // 0x0050(0x0010) (ZeroConstructor, Transient, NativeAccessSpecifierPublic)
bool bImplemented; // 0x0060(0x0001) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_2AFO[0x7]; // 0x0061(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimSegment
// 0x0020
struct FAnimSegment
{
class UAnimSequenceBase* AnimReference; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float StartPos; // 0x0008(0x0004) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AnimStartTime; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AnimEndTime; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AnimPlayRate; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LoopingCount; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_64CI[0x4]; // 0x001C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimTrack
// 0x0010
struct FAnimTrack
{
TArray<struct FAnimSegment> AnimSegments; // 0x0000(0x0010) (Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RootMotionExtractionStep
// 0x0010
struct FRootMotionExtractionStep
{
class UAnimSequence* AnimSequence; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float StartPosition; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float EndPosition; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CompressedSegment
// 0x0010
struct FCompressedSegment
{
unsigned char UnknownData_BFAG[0x10]; // 0x0000(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.FloatCurve
// 0x0080 (0x0098 - 0x0018)
struct FFloatCurve : public FAnimCurveBase
{
struct FRichCurve FloatCurve; // 0x0018(0x0080) (NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RawCurveTracks
// 0x0010
struct FRawCurveTracks
{
TArray<struct FFloatCurve> FloatCurves; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.VectorCurve
// 0x0180 (0x0198 - 0x0018)
struct FVectorCurve : public FAnimCurveBase
{
struct FRichCurve FloatCurves[0x3]; // 0x0018(0x0180) (NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TransformCurve
// 0x04C8 (0x04E0 - 0x0018)
struct FTransformCurve : public FAnimCurveBase
{
struct FVectorCurve TranslationCurve; // 0x0018(0x0198) (NativeAccessSpecifierPublic)
struct FVectorCurve RotationCurve; // 0x01B0(0x0198) (NativeAccessSpecifierPublic)
struct FVectorCurve ScaleCurve; // 0x0348(0x0198) (NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SlotEvaluationPose
// 0x0040
struct FSlotEvaluationPose
{
TEnumAsByte<EAdditiveAnimationType> AdditiveType; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_MU45[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float Weight; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_D65G[0x38]; // 0x0008(0x0038) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.A2Pose
// 0x0010
struct FA2Pose
{
TArray<struct FTransform> Bones; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.A2CSPose
// 0x0018 (0x0028 - 0x0010)
struct FA2CSPose : public FA2Pose
{
unsigned char UnknownData_MM7D[0x8]; // 0x0010(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<unsigned char> ComponentSpaceFlags; // 0x0018(0x0010) (ZeroConstructor, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.QueuedDrawDebugItem
// 0x0068
struct FQueuedDrawDebugItem
{
TEnumAsByte<EDrawDebugItemType> ItemType; // 0x0000(0x0001) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_GH45[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FVector StartLoc; // 0x0004(0x000C) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector EndLoc; // 0x0010(0x000C) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Center; // 0x001C(0x000C) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x0028(0x000C) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
float Radius; // 0x0034(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Size; // 0x0038(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int Segments; // 0x003C(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FColor Color; // 0x0040(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bPersistentLines; // 0x0044(0x0001) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_4UR9[0x3]; // 0x0045(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float LifeTime; // 0x0048(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Thickness; // 0x004C(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString Message; // 0x0050(0x0010) (ZeroConstructor, Transient, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D TextScale; // 0x0060(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimLinkableElement
// 0x0030
struct FAnimLinkableElement
{
unsigned char UnknownData_TNUK[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UAnimMontage* LinkedMontage; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
int SlotIndex; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
int SegmentIndex; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TEnumAsByte<EAnimLinkMethod> LinkMethod; // 0x0018(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TEnumAsByte<EAnimLinkMethod> CachedLinkMethod; // 0x0019(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
unsigned char UnknownData_R32A[0x2]; // 0x001A(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float SegmentBeginTime; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float SegmentLength; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float LinkValue; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class UAnimSequenceBase* LinkedSequence; // 0x0028(0x0008) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
};
// ScriptStruct Engine.AnimNotifyEvent
// 0x0088 (0x00B8 - 0x0030)
struct FAnimNotifyEvent : public FAnimLinkableElement
{
float DisplayTime; // 0x0030(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TriggerTimeOffset; // 0x0034(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float EndTriggerTimeOffset; // 0x0038(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TriggerWeightThreshold; // 0x003C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName NotifyName; // 0x0040(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UAnimNotify* Notify; // 0x0048(0x0008) (Edit, BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UAnimNotifyState* NotifyStateClass; // 0x0050(0x0008) (Edit, BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Duration; // 0x0058(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_CCFD[0x4]; // 0x005C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FAnimLinkableElement EndLink; // 0x0060(0x0030) (NativeAccessSpecifierPublic)
bool bConvertedFromBranchingPoint; // 0x0090(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EMontageNotifyTickType> MontageTickType; // 0x0091(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_GBXP[0x2]; // 0x0092(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float NotifyTriggerChance; // 0x0094(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ENotifyFilterType> NotifyFilterType; // 0x0098(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_8A3A[0x3]; // 0x0099(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int NotifyFilterLOD; // 0x009C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bTriggerOnDedicatedServer; // 0x00A0(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bTriggerOnFollower; // 0x00A1(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_3PGR[0x2]; // 0x00A2(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int TrackIndex; // 0x00A4(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_LK7N[0x10]; // 0x00A8(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimMontageInstance
// 0x01A8
struct FAnimMontageInstance
{
class UAnimMontage* Montage; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_S7EM[0x20]; // 0x0008(0x0020) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
bool bPlaying; // 0x0028(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_2TL3[0x3]; // 0x0029(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float DefaultBlendTimeMultiplier; // 0x002C(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_JF82[0xB8]; // 0x0030(0x00B8) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<int> NextSections; // 0x00E8(0x0010) (ZeroConstructor, NativeAccessSpecifierPrivate)
TArray<int> PrevSections; // 0x00F8(0x0010) (ZeroConstructor, NativeAccessSpecifierPrivate)
unsigned char UnknownData_Y0HL[0x10]; // 0x0108(0x0010) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FAnimNotifyEvent> ActiveStateBranchingPoints; // 0x0118(0x0010) (ZeroConstructor, Transient, ContainsInstancedReference, NativeAccessSpecifierPrivate)
float Position; // 0x0128(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
float PlayRate; // 0x012C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
struct FAlphaBlend Blend; // 0x0130(0x0030) (Transient, NoDestructor, NativeAccessSpecifierPrivate)
unsigned char UnknownData_B5H2[0x20]; // 0x0160(0x0020) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int DisableRootMotionCount; // 0x0180(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_K1IG[0x24]; // 0x0184(0x0024) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BranchingPointMarker
// 0x000C
struct FBranchingPointMarker
{
int NotifyIndex; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TriggerTime; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EAnimNotifyEventType> NotifyEventType; // 0x0008(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_F2R3[0x3]; // 0x0009(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BranchingPoint
// 0x0010 (0x0040 - 0x0030)
struct FBranchingPoint : public FAnimLinkableElement
{
struct FName EventName; // 0x0030(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DisplayTime; // 0x0038(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TriggerTimeOffset; // 0x003C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SlotAnimationTrack
// 0x0018
struct FSlotAnimationTrack
{
struct FName SlotName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FAnimTrack AnimTrack; // 0x0008(0x0010) (Edit, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CompositeSection
// 0x0028 (0x0058 - 0x0030)
struct FCompositeSection : public FAnimLinkableElement
{
struct FName SectionName; // 0x0030(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float StartTime; // 0x0038(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName NextSectionName; // 0x003C(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_L2DE[0x4]; // 0x0044(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<class UAnimMetaData*> MetaData; // 0x0048(0x0010) (Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimNode_ApplyMeshSpaceAdditive
// 0x0038 (0x0048 - 0x0010)
struct FAnimNode_ApplyMeshSpaceAdditive : public FAnimNode_Base
{
struct FPoseLink Base; // 0x0010(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
struct FPoseLink Additive; // 0x0020(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
float Alpha; // 0x0030(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FInputScaleBias AlphaScaleBias; // 0x0034(0x0008) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
int LODThreshold; // 0x003C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_0B2E[0x8]; // 0x0040(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_CustomProperty
// 0x0048 (0x0058 - 0x0010)
struct FAnimNode_CustomProperty : public FAnimNode_Base
{
TArray<struct FName> SourcePropertyNames; // 0x0010(0x0010) (ZeroConstructor, Protected, NativeAccessSpecifierProtected)
TArray<struct FName> DestPropertyNames; // 0x0020(0x0010) (ZeroConstructor, Protected, NativeAccessSpecifierProtected)
class UObject* TargetInstance; // 0x0030(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TArray<class UProperty*> SourceProperties; // 0x0038(0x0010) (ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
TArray<class UProperty*> DestProperties; // 0x0048(0x0010) (ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
};
// ScriptStruct Engine.AnimNode_SubInstance
// 0x0038 (0x0090 - 0x0058)
struct FAnimNode_SubInstance : public FAnimNode_CustomProperty
{
TArray<struct FPoseLink> InputPoses; // 0x0058(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FName> InputPoseNames; // 0x0068(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
class UClass* InstanceClass; // 0x0078(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName Tag; // 0x0080(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_83LW[0x8]; // 0x0088(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_Layer
// 0x0010 (0x00A0 - 0x0090)
struct FAnimNode_Layer : public FAnimNode_SubInstance
{
class UClass* Interface; // 0x0090(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName Layer; // 0x0098(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimNode_SaveCachedPose
// 0x00A8 (0x00B8 - 0x0010)
struct FAnimNode_SaveCachedPose : public FAnimNode_Base
{
struct FPoseLink Pose; // 0x0010(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
struct FName CachePoseName; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Z3F3[0x90]; // 0x0028(0x0090) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_SequencePlayer
// 0x0048 (0x0078 - 0x0030)
struct FAnimNode_SequencePlayer : public FAnimNode_AssetPlayerBase
{
class UAnimSequenceBase* Sequence; // 0x0030(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PlayRateBasis; // 0x0038(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PlayRate; // 0x003C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FInputScaleBiasClamp PlayRateScaleBiasClamp; // 0x0040(0x0030) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
float StartPosition; // 0x0070(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bLoopAnimation; // 0x0074(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_BBMC[0x3]; // 0x0075(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNotifyEventReference
// 0x0010
struct FAnimNotifyEventReference
{
unsigned char UnknownData_I4QQ[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UObject* NotifySource; // 0x0008(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.AnimNode_StateMachine
// 0x00A0 (0x00B0 - 0x0010)
struct FAnimNode_StateMachine : public FAnimNode_Base
{
int StateMachineIndexInClass; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MaxTransitionsPerFrame; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bSkipFirstUpdateTransition; // 0x0018(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bReinitializeOnBecomingRelevant; // 0x0019(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_DEC1[0x96]; // 0x001A(0x0096) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimationPotentialTransition
// 0x0030
struct FAnimationPotentialTransition
{
unsigned char UnknownData_Z7GA[0x30]; // 0x0000(0x0030) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNotifyArray
// 0x0010
struct FAnimNotifyArray
{
TArray<struct FAnimNotifyEventReference> Notifies; // 0x0000(0x0010) (ZeroConstructor, Transient, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimNotifyQueue
// 0x0070
struct FAnimNotifyQueue
{
unsigned char UnknownData_BSSQ[0x10]; // 0x0000(0x0010) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FAnimNotifyEventReference> AnimNotifies; // 0x0010(0x0010) (ZeroConstructor, Transient, NativeAccessSpecifierPublic)
TMap<struct FName, struct FAnimNotifyArray> UnfilteredMontageAnimNotifies; // 0x0020(0x0050) (ZeroConstructor, Transient, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimationActiveTransitionEntry
// 0x00C8
struct FAnimationActiveTransitionEntry
{
unsigned char UnknownData_C3BW[0xB8]; // 0x0000(0x00B8) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UBlendProfile* BlendProfile; // 0x00B8(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_8CNI[0x8]; // 0x00C0(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_SubInput
// 0x0060 (0x0070 - 0x0010)
struct FAnimNode_SubInput : public FAnimNode_Base
{
struct FName Name; // 0x0010(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName Graph; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FPoseLink InputPose; // 0x0020(0x0010) (NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_UUCQ[0x40]; // 0x0030(0x0040) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_TransitionPoseEvaluator
// 0x0048 (0x0058 - 0x0010)
struct FAnimNode_TransitionPoseEvaluator : public FAnimNode_Base
{
unsigned char UnknownData_VPEE[0x38]; // 0x0010(0x0038) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int FramesToCachePose; // 0x0048(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_POUR[0x4]; // 0x004C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<EEvaluatorDataSource> DataSource; // 0x0050(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EEvaluatorMode> EvaluatorMode; // 0x0051(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_MWBV[0x6]; // 0x0052(0x0006) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_TransitionResult
// 0x0018 (0x0028 - 0x0010)
struct FAnimNode_TransitionResult : public FAnimNode_Base
{
bool bCanEnterTransition; // 0x0010(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_8APA[0x17]; // 0x0011(0x0017) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_UseCachedPose
// 0x0018 (0x0028 - 0x0010)
struct FAnimNode_UseCachedPose : public FAnimNode_Base
{
struct FPoseLink LinkToCachingNode; // 0x0010(0x0010) (NoDestructor, NativeAccessSpecifierPublic)
struct FName CachePoseName; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ExposedValueCopyRecord
// 0x0038
struct FExposedValueCopyRecord
{
struct FName SourcePropertyName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName SourceSubPropertyName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int SourceArrayIndex; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bInstanceIsTarget; // 0x0014(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EPostCopyOperation PostCopyOperation; // 0x0015(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
ECopyType CopyType; // 0x0016(0x0001) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_WKVH[0x1]; // 0x0017(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UProperty* DestProperty; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int DestArrayIndex; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int Size; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UProperty* CachedSourceProperty; // 0x0028(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UProperty* CachedSourceStructSubProperty; // 0x0030(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ExposedValueHandler
// 0x0030
struct FExposedValueHandler
{
struct FName BoundFunction; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FExposedValueCopyRecord> CopyRecords; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
class UFunction* Function; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UStructProperty* ValueHandlerNodeProperty; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_LY0H[0x8]; // 0x0028(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_ConvertLocalToComponentSpace
// 0x0010 (0x0020 - 0x0010)
struct FAnimNode_ConvertLocalToComponentSpace : public FAnimNode_Base
{
struct FPoseLink LocalPose; // 0x0010(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimNode_ConvertComponentToLocalSpace
// 0x0010 (0x0020 - 0x0010)
struct FAnimNode_ConvertComponentToLocalSpace : public FAnimNode_Base
{
struct FComponentSpacePoseLink ComponentPose; // 0x0010(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CompressedTrack
// 0x0038
struct FCompressedTrack
{
TArray<unsigned char> ByteStream; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<float> Times; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
float Mins[0x3]; // 0x0020(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Ranges[0x3]; // 0x002C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CurveTrack
// 0x0018
struct FCurveTrack
{
struct FName CurveName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<float> CurveWeights; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ScaleTrack
// 0x0020
struct FScaleTrack
{
TArray<struct FVector> ScaleKeys; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<float> Times; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RotationTrack
// 0x0020
struct FRotationTrack
{
TArray<struct FQuat> RotKeys; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<float> Times; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TranslationTrack
// 0x0020
struct FTranslationTrack
{
TArray<struct FVector> PosKeys; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<float> Times; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RawAnimSequenceTrack
// 0x0030
struct FRawAnimSequenceTrack
{
TArray<struct FVector> PosKeys; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FQuat> RotKeys; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FVector> ScaleKeys; // 0x0020(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimSequenceTrackContainer
// 0x0020
struct FAnimSequenceTrackContainer
{
TArray<struct FRawAnimSequenceTrack> AnimationTracks; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FName> TrackNames; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimSetMeshLinkup
// 0x0010
struct FAnimSetMeshLinkup
{
TArray<int> BoneToTrackTable; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimSingleNodeInstanceProxy
// 0x0150 (0x0820 - 0x06D0)
struct FAnimSingleNodeInstanceProxy : public FAnimInstanceProxy
{
unsigned char UnknownData_7AEP[0x150]; // 0x06D0(0x0150) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNode_SingleNode
// 0x0020 (0x0030 - 0x0010)
struct FAnimNode_SingleNode : public FAnimNode_Base
{
struct FPoseLink SourcePose; // 0x0010(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_2PY7[0x10]; // 0x0020(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BakedStateExitTransition
// 0x0020
struct FBakedStateExitTransition
{
int CanTakeDelegateIndex; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int CustomResultNodeIndex; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int TransitionIndex; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bDesiredTransitionReturnValue; // 0x000C(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAutomaticRemainingTimeRule; // 0x000D(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_WMVJ[0x2]; // 0x000E(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<int> PoseEvaluatorLinks; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BakedAnimationState
// 0x0048
struct FBakedAnimationState
{
struct FName StateName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FBakedStateExitTransition> Transitions; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
int StateRootNodeIndex; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int StartNotify; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int EndNotify; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int FullyBlendedNotify; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bIsAConduit; // 0x0028(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_95F7[0x3]; // 0x0029(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int EntryRuleNodeIndex; // 0x002C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<int> PlayerNodeIndices; // 0x0030(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
bool bAlwaysResetOnEntry; // 0x0040(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Y6E0[0x7]; // 0x0041(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimationStateBase
// 0x0008
struct FAnimationStateBase
{
struct FName StateName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimationTransitionBetweenStates
// 0x0038 (0x0040 - 0x0008)
struct FAnimationTransitionBetweenStates : public FAnimationStateBase
{
int PreviousState; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int NextState; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CrossfadeDuration; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int StartNotify; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int EndNotify; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int InterruptNotify; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EAlphaBlendOption BlendMode; // 0x0020(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_JN9F[0x7]; // 0x0021(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UCurveFloat* CustomCurve; // 0x0028(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UBlendProfile* BlendProfile; // 0x0030(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ETransitionLogicType> LogicType; // 0x0038(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_1TTM[0x7]; // 0x0039(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BakedAnimationStateMachine
// 0x0030
struct FBakedAnimationStateMachine
{
struct FName MachineName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int InitialState; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_5FHU[0x4]; // 0x000C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FBakedAnimationState> States; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FAnimationTransitionBetweenStates> Transitions; // 0x0020(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimationTransitionRule
// 0x0010
struct FAnimationTransitionRule
{
struct FName RuleToExecute; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool TransitionReturnVal; // 0x0008(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_08JK[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int TransitionIndex; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimationState
// 0x0020 (0x0028 - 0x0008)
struct FAnimationState : public FAnimationStateBase
{
TArray<struct FAnimationTransitionRule> Transitions; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
int StateRootNodeIndex; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int StartNotify; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int EndNotify; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int FullyBlendedNotify; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TrackToSkeletonMap
// 0x0004
struct FTrackToSkeletonMap
{
int BoneTreeIndex; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimSyncMarker
// 0x000C
struct FAnimSyncMarker
{
struct FName MarkerName; // 0x0000(0x0008) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Time; // 0x0008(0x0004) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MarkerSyncData
// 0x0020
struct FMarkerSyncData
{
TArray<struct FAnimSyncMarker> AuthoredSyncMarkers; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_UKPU[0x10]; // 0x0010(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimNotifyTrack
// 0x0038
struct FAnimNotifyTrack
{
struct FName TrackName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor TrackColor; // 0x0008(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VWSG[0x20]; // 0x0018(0x0020) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PerBoneBlendWeights
// 0x0010
struct FPerBoneBlendWeights
{
TArray<struct FPerBoneBlendWeight> BoneBlendWeights; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AssetImportInfo
// 0x0001
struct FAssetImportInfo
{
unsigned char UnknownData_74NU[0x1]; // 0x0000(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PrimaryAssetRules
// 0x0010
struct FPrimaryAssetRules
{
int Priority; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bApplyRecursively; // 0x0004(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EATB[0x3]; // 0x0005(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int ChunkId; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EPrimaryAssetCookRule CookRule; // 0x000C(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_W4NN[0x3]; // 0x000D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PrimaryAssetRulesCustomOverride
// 0x0038
struct FPrimaryAssetRulesCustomOverride
{
struct FPrimaryAssetType PrimaryAssetType; // 0x0000(0x0008) (Edit, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FDirectoryPath FilterDirectory; // 0x0008(0x0010) (Edit, NativeAccessSpecifierPublic)
struct FString FilterString; // 0x0018(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FPrimaryAssetRules Rules; // 0x0028(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.GeomSelection
// 0x000C
struct FGeomSelection
{
int Type; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int Index; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int SelectionIndex; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PrimaryAssetRulesOverride
// 0x0020
struct FPrimaryAssetRulesOverride
{
struct FPrimaryAssetId PrimaryAssetId; // 0x0000(0x0010) (Edit, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FPrimaryAssetRules Rules; // 0x0010(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AssetManagerRedirect
// 0x0020
struct FAssetManagerRedirect
{
struct FString Old; // 0x0000(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString New; // 0x0010(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ReverbSettings
// 0x0020
struct FReverbSettings
{
bool bApplyReverb; // 0x0000(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_TKX5[0x7]; // 0x0001(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UReverbEffect* ReverbEffect; // 0x0008(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class USoundEffectSubmixPreset* ReverbPluginEffect; // 0x0010(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Volume; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FadeTime; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InteriorSettings
// 0x0024
struct FInteriorSettings
{
bool bIsWorldSettings; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_WFYY[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float ExteriorVolume; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ExteriorTime; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ExteriorLPF; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ExteriorLPFTime; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float InteriorVolume; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float InteriorTime; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float InteriorLPF; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float InteriorLPFTime; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PrimaryAssetTypeInfo
// 0x0088
struct FPrimaryAssetTypeInfo
{
struct FName PrimaryAssetType; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char AssetBaseClass[0x28]; // 0x0008(0x0028) UNKNOWN PROPERTY: SoftClassProperty Engine.PrimaryAssetTypeInfo.AssetBaseClass
class UClass* AssetBaseClassLoaded; // 0x0030(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bHasBlueprintClasses; // 0x0038(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bIsEditorOnly; // 0x0039(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_UYJV[0x6]; // 0x003A(0x0006) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FDirectoryPath> Directories; // 0x0040(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
TArray<struct FSoftObjectPath> SpecificAssets; // 0x0050(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
struct FPrimaryAssetRules Rules; // 0x0060(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
TArray<struct FString> AssetScanPaths; // 0x0070(0x0010) (ZeroConstructor, Transient, NativeAccessSpecifierPublic)
bool bIsDynamicAsset; // 0x0080(0x0001) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_FDAU[0x3]; // 0x0081(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int NumberOfAssets; // 0x0084(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AssetMapping
// 0x0010
struct FAssetMapping
{
class UAnimationAsset* SourceAsset; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UAnimationAsset* TargetAsset; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AtmospherePrecomputeInstanceData
// 0x01E0 (0x0288 - 0x00A8)
struct FAtmospherePrecomputeInstanceData : public FSceneComponentInstanceData
{
unsigned char UnknownData_FL1G[0x1E0]; // 0x00A8(0x01E0) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AtmospherePrecomputeParameters
// 0x002C
struct FAtmospherePrecomputeParameters
{
float DensityHeight; // 0x0000(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DecayHeight; // 0x0004(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MaxScatteringOrder; // 0x0008(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int TransmittanceTexWidth; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int TransmittanceTexHeight; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int IrradianceTexWidth; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int IrradianceTexHeight; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int InscatterAltitudeSampleNum; // 0x001C(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int InscatterMuNum; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int InscatterMuSNum; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int InscatterNuNum; // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AudioComponentParam
// 0x0020
struct FAudioComponentParam
{
struct FName ParamName; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FloatParam; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool BoolParam; // 0x000C(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_PTIS[0x3]; // 0x000D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int IntParam; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_RP74[0x4]; // 0x0014(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class USoundWave* SoundWaveParam; // 0x0018(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AudioQualitySettings
// 0x0020
struct FAudioQualitySettings
{
struct FText DisplayName; // 0x0000(0x0018) (Edit, NativeAccessSpecifierPublic)
int MaxChannels; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_NXQ7[0x4]; // 0x001C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LaunchOnTestSettings
// 0x0020
struct FLaunchOnTestSettings
{
struct FFilePath LaunchOnTestmap; // 0x0000(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
struct FString DeviceID; // 0x0010(0x0010) (Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EditorMapPerformanceTestDefinition
// 0x0020
struct FEditorMapPerformanceTestDefinition
{
struct FSoftObjectPath PerformanceTestmap; // 0x0000(0x0018) (Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int TestTimer; // 0x0018(0x0004) (Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_U11L[0x4]; // 0x001C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ImportFactorySettingValues
// 0x0020
struct FImportFactorySettingValues
{
struct FString SettingName; // 0x0000(0x0010) (Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString Value; // 0x0010(0x0010) (Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EditorImportWorkflowDefinition
// 0x0020
struct FEditorImportWorkflowDefinition
{
struct FFilePath ImportFilePath; // 0x0000(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
TArray<struct FImportFactorySettingValues> FactorySettings; // 0x0010(0x0010) (Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BuildPromotionImportWorkflowSettings
// 0x0150
struct FBuildPromotionImportWorkflowSettings
{
struct FEditorImportWorkflowDefinition Diffuse; // 0x0000(0x0020) (Edit, Config, NativeAccessSpecifierPublic)
struct FEditorImportWorkflowDefinition Normal; // 0x0020(0x0020) (Edit, Config, NativeAccessSpecifierPublic)
struct FEditorImportWorkflowDefinition StaticMesh; // 0x0040(0x0020) (Edit, Config, NativeAccessSpecifierPublic)
struct FEditorImportWorkflowDefinition ReimportStaticMesh; // 0x0060(0x0020) (Edit, Config, NativeAccessSpecifierPublic)
struct FEditorImportWorkflowDefinition BlendShapeMesh; // 0x0080(0x0020) (Edit, Config, NativeAccessSpecifierPublic)
struct FEditorImportWorkflowDefinition MorphMesh; // 0x00A0(0x0020) (Edit, Config, NativeAccessSpecifierPublic)
struct FEditorImportWorkflowDefinition SkeletalMesh; // 0x00C0(0x0020) (Edit, Config, NativeAccessSpecifierPublic)
struct FEditorImportWorkflowDefinition Animation; // 0x00E0(0x0020) (Edit, Config, NativeAccessSpecifierPublic)
struct FEditorImportWorkflowDefinition Sound; // 0x0100(0x0020) (Edit, Config, NativeAccessSpecifierPublic)
struct FEditorImportWorkflowDefinition SurroundSound; // 0x0120(0x0020) (Edit, Config, NativeAccessSpecifierPublic)
TArray<struct FEditorImportWorkflowDefinition> OtherAssetsToImport; // 0x0140(0x0010) (Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BuildPromotionOpenAssetSettings
// 0x0060
struct FBuildPromotionOpenAssetSettings
{
struct FFilePath BlueprintAsset; // 0x0000(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
struct FFilePath MaterialAsset; // 0x0010(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
struct FFilePath ParticleSystemAsset; // 0x0020(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
struct FFilePath SkeletalMeshAsset; // 0x0030(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
struct FFilePath StaticMeshAsset; // 0x0040(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
struct FFilePath TextureAsset; // 0x0050(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BuildPromotionNewProjectSettings
// 0x0020
struct FBuildPromotionNewProjectSettings
{
struct FDirectoryPath NewProjectFolderOverride; // 0x0000(0x0010) (Edit, NativeAccessSpecifierPublic)
struct FString NewProjectNameOverride; // 0x0010(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BuildPromotionTestSettings
// 0x01F0
struct FBuildPromotionTestSettings
{
struct FFilePath DefaultStaticMeshAsset; // 0x0000(0x0010) (Edit, NativeAccessSpecifierPublic)
struct FBuildPromotionImportWorkflowSettings ImportWorkflow; // 0x0010(0x0150) (Edit, NativeAccessSpecifierPublic)
struct FBuildPromotionOpenAssetSettings OpenAssets; // 0x0160(0x0060) (Edit, NativeAccessSpecifierPublic)
struct FBuildPromotionNewProjectSettings NewProjectSettings; // 0x01C0(0x0020) (Edit, NativeAccessSpecifierPublic)
struct FFilePath SourceControlMaterial; // 0x01E0(0x0010) (Edit, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MovementProperties
// 0x0001
struct FMovementProperties
{
unsigned char bCanCrouch : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCanJump : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCanWalk : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCanSwim : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCanFly : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NavAgentProperties
// 0x002F (0x0030 - 0x0001)
struct FNavAgentProperties : public FMovementProperties
{
unsigned char UnknownData_5K0J[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float AgentRadius; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AgentHeight; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AgentStepHeight; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NavWalkingSearchHeightScale; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_7DGC[0x4]; // 0x0014(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FSoftClassPath PreferredNavData; // 0x0018(0x0018) (Edit, BlueprintVisible, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BlueprintEditorPromotionSettings
// 0x0030
struct FBlueprintEditorPromotionSettings
{
struct FFilePath FirstMeshPath; // 0x0000(0x0010) (Edit, NativeAccessSpecifierPublic)
struct FFilePath SecondMeshPath; // 0x0010(0x0010) (Edit, NativeAccessSpecifierPublic)
struct FFilePath DefaultParticleAsset; // 0x0020(0x0010) (Edit, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ParticleEditorPromotionSettings
// 0x0010
struct FParticleEditorPromotionSettings
{
struct FFilePath DefaultParticleAsset; // 0x0000(0x0010) (Edit, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MaterialEditorPromotionSettings
// 0x0030
struct FMaterialEditorPromotionSettings
{
struct FFilePath DefaultMaterialAsset; // 0x0000(0x0010) (Edit, NativeAccessSpecifierPublic)
struct FFilePath DefaultDiffuseTexture; // 0x0010(0x0010) (Edit, NativeAccessSpecifierPublic)
struct FFilePath DefaultNormalTexture; // 0x0020(0x0010) (Edit, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EditorImportExportTestDefinition
// 0x0038
struct FEditorImportExportTestDefinition
{
struct FFilePath ImportFilePath; // 0x0000(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
struct FString ExportFileExtension; // 0x0010(0x0010) (Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bSkipExport; // 0x0020(0x0001) (Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_FGHP[0x7]; // 0x0021(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FImportFactorySettingValues> FactorySettings; // 0x0028(0x0010) (Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ExternalToolDefinition
// 0x0060
struct FExternalToolDefinition
{
struct FString ToolName; // 0x0000(0x0010) (Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FFilePath ExecutablePath; // 0x0010(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
struct FString CommandLineOptions; // 0x0020(0x0010) (Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FDirectoryPath WorkingDirectory; // 0x0030(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
struct FString ScriptExtension; // 0x0040(0x0010) (Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FDirectoryPath ScriptDirectory; // 0x0050(0x0010) (Edit, Config, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NavAvoidanceData
// 0x003C
struct FNavAvoidanceData
{
unsigned char UnknownData_AWCD[0x3C]; // 0x0000(0x003C) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BlendProfileBoneEntry
// 0x0014
struct FBlendProfileBoneEntry
{
struct FBoneReference BoneReference; // 0x0000(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
float BlendScale; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PerBoneInterpolation
// 0x0014
struct FPerBoneInterpolation
{
struct FBoneReference BoneReference; // 0x0000(0x0010) (Edit, NoDestructor, NativeAccessSpecifierPublic)
float InterpolationSpeedPerSec; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EditorElement
// 0x0018
struct FEditorElement
{
int Indices[0x3]; // 0x0000(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Weights[0x3]; // 0x000C(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.GridBlendSample
// 0x001C
struct FGridBlendSample
{
struct FEditorElement GridElement; // 0x0000(0x0018) (NoDestructor, NativeAccessSpecifierPublic)
float BlendWeight; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BlendSample
// 0x0018
struct FBlendSample
{
class UAnimSequence* Animation; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector SampleValue; // 0x0008(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float RateScale; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BlendParameter
// 0x0020
struct FBlendParameter
{
struct FString DisplayName; // 0x0000(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Min; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Max; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int GridNum; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_QERE[0x4]; // 0x001C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.InterpolationParameter
// 0x0008
struct FInterpolationParameter
{
float InterpolationTime; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EFilterInterpolationType> InterpolationType; // 0x0004(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_6H9Q[0x3]; // 0x0005(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BPEditorBookmarkNode
// 0x0038
struct FBPEditorBookmarkNode
{
struct FGuid NodeGuid; // 0x0000(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid ParentGuid; // 0x0010(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FText DisplayName; // 0x0020(0x0018) (NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EditedDocumentInfo
// 0x0030
struct FEditedDocumentInfo
{
struct FSoftObjectPath EditedObjectPath; // 0x0000(0x0018) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D SavedViewOffset; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SavedZoomAmount; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_GX41[0x4]; // 0x0024(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UObject* EditedObject; // 0x0028(0x0008) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.BPInterfaceDescription
// 0x0018
struct FBPInterfaceDescription
{
class UClass* Interface; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<class UEdGraph*> Graphs; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EdGraphTerminalType
// 0x001C
struct FEdGraphTerminalType
{
struct FName TerminalCategory; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName TerminalSubCategory; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TWeakObjectPtr<class UObject> TerminalSubCategoryObject; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bTerminalIsConst; // 0x0018(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bTerminalIsWeakPointer; // 0x0019(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_2V46[0x2]; // 0x001A(0x0002) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BasedMovementInfo
// 0x0030
struct FBasedMovementInfo
{
class UPrimitiveComponent* MovementBase; // 0x0000(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName BoneName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantize100 Location; // 0x0010(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x001C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
bool bServerHasBaseComponent; // 0x0028(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bRelativeRotation; // 0x0029(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bServerHasVelocity; // 0x002A(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_2ZUI[0x5]; // 0x002B(0x0005) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.EdGraphPinType
// 0x0058
struct FEdGraphPinType
{
struct FName PinCategory; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName PinSubCategory; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TWeakObjectPtr<class UObject> PinSubCategoryObject; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FSimpleMemberReference PinSubCategoryMemberReference; // 0x0018(0x0020) (NoDestructor, NativeAccessSpecifierPublic)
struct FEdGraphTerminalType PinValueType; // 0x0038(0x001C) (NoDestructor, NativeAccessSpecifierPublic)
EPinContainerType ContainerType; // 0x0054(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIsArray : 1; // 0x0055(0x0001) BIT_FIELD (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char bIsReference : 1; // 0x0055(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIsConst : 1; // 0x0055(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIsWeakPointer : 1; // 0x0055(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Q9CS[0x2]; // 0x0056(0x0002) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.Vector_NetQuantize10
// 0x0000 (0x000C - 0x000C)
struct FVector_NetQuantize10 : public FVector
{
};
// ScriptStruct Engine.BPVariableMetaDataEntry
// 0x0018
struct FBPVariableMetaDataEntry
{
struct FName DataKey; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString DataValue; // 0x0008(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RootMotionSourceGroup
// 0x00F8
struct FRootMotionSourceGroup
{
unsigned char UnknownData_HDS2[0xE8]; // 0x0000(0x00E8) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bHasAdditiveSources : 1; // 0x00E8(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bHasOverrideSources : 1; // 0x00E8(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIsAdditiveVelocityApplied : 1; // 0x00E8(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRootMotionSourceSettings LastAccumulatedSettings; // 0x00E9(0x0001) (NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_WVS1[0x2]; // 0x00EA(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FVector_NetQuantize10 LastPreAdditiveVelocity; // 0x00EC(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BPVariableDescription
// 0x00D0
struct FBPVariableDescription
{
struct FName VarName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid VarGuid; // 0x0008(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FEdGraphPinType VarType; // 0x0018(0x0058) (Edit, NoDestructor, NativeAccessSpecifierPublic)
struct FString FriendlyName; // 0x0070(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FText Category; // 0x0080(0x0018) (Edit, NativeAccessSpecifierPublic)
uint64_t PropertyFlags; // 0x0098(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName RepNotifyFunc; // 0x00A0(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ELifetimeCondition> ReplicationCondition; // 0x00A8(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_00MH[0x7]; // 0x00A9(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FBPVariableMetaDataEntry> MetaDataArray; // 0x00B0(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
struct FString DefaultValue; // 0x00C0(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BlueprintMacroCosmeticInfo
// 0x0001
struct FBlueprintMacroCosmeticInfo
{
unsigned char UnknownData_PXZ5[0x1]; // 0x0000(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CompilerNativizationOptions
// 0x0080
struct FCompilerNativizationOptions
{
struct FName PlatformName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool ServerOnlyPlatform; // 0x0008(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool ClientOnlyPlatform; // 0x0009(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bExcludeMonolithicHeaders; // 0x000A(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ERBA[0x5]; // 0x000B(0x0005) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FName> ExcludedModules; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char ExcludedAssets[0x50]; // 0x0020(0x0050) UNKNOWN PROPERTY: SetProperty Engine.CompilerNativizationOptions.ExcludedAssets
TArray<struct FString> ExcludedFolderPaths; // 0x0070(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BlueprintComponentChangedPropertyInfo
// 0x0018
struct FBlueprintComponentChangedPropertyInfo
{
struct FName PropertyName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ArrayIndex; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_MCY5[0x4]; // 0x000C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UStruct* PropertyScope; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RepRootMotionMontage
// 0x0158
struct FRepRootMotionMontage
{
bool bIsActive; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_1HKK[0x7]; // 0x0001(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UAnimMontage* AnimMontage; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Position; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantize100 Location; // 0x0014(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x0020(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_EEK3[0x4]; // 0x002C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UPrimitiveComponent* MovementBase; // 0x0030(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName MovementBaseBoneName; // 0x0038(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bRelativePosition; // 0x0040(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bRelativeRotation; // 0x0041(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ECQX[0x6]; // 0x0042(0x0006) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FRootMotionSourceGroup AuthoritativeRootMotion; // 0x0048(0x00F8) (NativeAccessSpecifierPublic)
struct FVector_NetQuantize10 Acceleration; // 0x0140(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantize10 LinearVelocity; // 0x014C(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BlueprintCookedComponentInstancingData
// 0x0050
struct FBlueprintCookedComponentInstancingData
{
bool bHasValidCookedData; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_D1VU[0x7]; // 0x0001(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FBlueprintComponentChangedPropertyInfo> ChangedPropertyList; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_FDBC[0x38]; // 0x0018(0x0038) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SimulatedRootMotionReplicatedMove
// 0x0160
struct FSimulatedRootMotionReplicatedMove
{
float Time; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_JXRE[0x4]; // 0x0004(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FRepRootMotionMontage RootMotion; // 0x0008(0x0158) (ContainsInstancedReference, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EventGraphFastCallPair
// 0x0010
struct FEventGraphFastCallPair
{
class UFunction* FunctionToPatch; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int EventGraphCallOffset; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_9YE9[0x4]; // 0x000C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BlueprintDebugData
// 0x0001
struct FBlueprintDebugData
{
unsigned char UnknownData_7C1A[0x1]; // 0x0000(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PointerToUberGraphFrame
// 0x0008
struct FPointerToUberGraphFrame
{
unsigned char UnknownData_3IQT[0x8]; // 0x0000(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.DebuggingInfoForSingleFunction
// 0x0190
struct FDebuggingInfoForSingleFunction
{
unsigned char UnknownData_7WXV[0x190]; // 0x0000(0x0190) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.NodeToCodeAssociation
// 0x0014
struct FNodeToCodeAssociation
{
unsigned char UnknownData_QSDN[0x14]; // 0x0000(0x0014) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimCurveType
// 0x0002
struct FAnimCurveType
{
unsigned char UnknownData_GC2N[0x2]; // 0x0000(0x0002) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BookmarkBaseJumpToSettings
// 0x0001
struct FBookmarkBaseJumpToSettings
{
unsigned char UnknownData_5R4Y[0x1]; // 0x0000(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BookmarkJumpToSettings
// 0x0000 (0x0001 - 0x0001)
struct FBookmarkJumpToSettings : public FBookmarkBaseJumpToSettings
{
};
// ScriptStruct Engine.Bookmark2DJumpToSettings
// 0x0001
struct FBookmark2DJumpToSettings
{
unsigned char UnknownData_GIBZ[0x1]; // 0x0000(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BuilderPoly
// 0x0020
struct FBuilderPoly
{
TArray<int> VertexIndices; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
int Direction; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ItemName; // 0x0014(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int PolyFlags; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CachedAnimTransitionData
// 0x0024
struct FCachedAnimTransitionData
{
struct FName StateMachineName; // 0x0000(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName FromStateName; // 0x0008(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ToStateName; // 0x0010(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VT6P[0xC]; // 0x0018(0x000C) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CachedAnimRelevancyData
// 0x001C
struct FCachedAnimRelevancyData
{
struct FName StateMachineName; // 0x0000(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName StateName; // 0x0008(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_AK6C[0xC]; // 0x0010(0x000C) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CachedAnimAssetPlayerData
// 0x0018
struct FCachedAnimAssetPlayerData
{
struct FName StateMachineName; // 0x0000(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName StateName; // 0x0008(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_KQ45[0x8]; // 0x0010(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CachedAnimStateData
// 0x001C
struct FCachedAnimStateData
{
struct FName StateMachineName; // 0x0000(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName StateName; // 0x0008(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_LCXS[0xC]; // 0x0010(0x000C) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CachedAnimStateArray
// 0x0018
struct FCachedAnimStateArray
{
TArray<struct FCachedAnimStateData> States; // 0x0000(0x0010) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_PPW0[0x8]; // 0x0010(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PooledCameraShakes
// 0x0010
struct FPooledCameraShakes
{
TArray<class UCameraShake*> PooledShakes; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FOscillator
// 0x000C
struct FFOscillator
{
float Amplitude; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Frequency; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EInitialOscillatorOffset> InitialOffset; // 0x0008(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EOscillatorWaveform Waveform; // 0x0009(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_UD87[0x2]; // 0x000A(0x0002) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.VOscillator
// 0x0024
struct FVOscillator
{
struct FFOscillator X; // 0x0000(0x000C) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
struct FFOscillator Y; // 0x000C(0x000C) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
struct FFOscillator Z; // 0x0018(0x000C) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ROscillator
// 0x0024
struct FROscillator
{
struct FFOscillator Pitch; // 0x0000(0x000C) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
struct FFOscillator Yaw; // 0x000C(0x000C) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
struct FFOscillator Roll; // 0x0018(0x000C) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.DummySpacerCameraTypes
// 0x0001
struct FDummySpacerCameraTypes
{
unsigned char UnknownData_HD3V[0x1]; // 0x0000(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CanvasIcon
// 0x0018
struct FCanvasIcon
{
class UTexture* Texture; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float U; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float V; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float UL; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float VL; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.WrappedStringElement
// 0x0018
struct FWrappedStringElement
{
struct FString Value; // 0x0000(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D LineExtent; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TextSizingParameters
// 0x0028
struct FTextSizingParameters
{
float DrawX; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DrawY; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DrawXL; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DrawYL; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D Scaling; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UFont* DrawFont; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D SpacingAdjust; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CharacterMovementComponentPostPhysicsTickFunction
// 0x0008 (0x0058 - 0x0050)
struct FCharacterMovementComponentPostPhysicsTickFunction : public FTickFunction
{
unsigned char UnknownData_VKFS[0x8]; // 0x0050(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.FindFloorResult
// 0x0094
struct FFindFloorResult
{
unsigned char bBlockingHit : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnTemplate, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bWalkableFloor : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnTemplate, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLineTrace : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnTemplate, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_V8UJ[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float FloorDist; // 0x0004(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnTemplate, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LineDist; // 0x0008(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnTemplate, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FHitResult HitResult; // 0x000C(0x0088) (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnTemplate, EditConst, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ChildActorAttachedActorInfo
// 0x0040
struct FChildActorAttachedActorInfo
{
TWeakObjectPtr<class AActor> Actor; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName SocketName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FTransform RelativeTransform; // 0x0010(0x0030) (IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ChildActorComponentInstanceData
// 0x0028 (0x00D0 - 0x00A8)
struct FChildActorComponentInstanceData : public FSceneComponentInstanceData
{
struct FName ChildActorName; // 0x00A8(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FChildActorAttachedActorInfo> AttachedActors; // 0x00B0(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_GP5H[0x10]; // 0x00C0(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CustomProfile
// 0x0018
struct FCustomProfile
{
struct FName Name; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FResponseChannel> CustomResponses; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CustomChannelSetup
// 0x0010
struct FCustomChannelSetup
{
TEnumAsByte<ECollisionChannel> Channel; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_WJYU[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName Name; // 0x0004(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionResponse> DefaultResponse; // 0x000C(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bTraceType; // 0x000D(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bStaticObject; // 0x000E(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EK2I[0x1]; // 0x000F(0x0001) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CollisionResponseTemplate
// 0x0060
struct FCollisionResponseTemplate
{
struct FName Name; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionEnabled> CollisionEnabled; // 0x0008(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_4QDT[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName ObjectTypeName; // 0x000C(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_9I08[0x4]; // 0x0014(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<struct FResponseChannel> CustomResponses; // 0x0018(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
struct FString HelpMessage; // 0x0028(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bCanModify; // 0x0038(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ZKX4[0x27]; // 0x0039(0x0027) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BlueprintComponentDelegateBinding
// 0x0018
struct FBlueprintComponentDelegateBinding
{
struct FName ComponentPropertyName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName DelegatePropertyName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName FunctionNameToBind; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AutoCompleteNode
// 0x0028
struct FAutoCompleteNode
{
int IndexChar; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_F5D8[0x4]; // 0x0004(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<int> AutoCompleteListIndices; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_JRYT[0x10]; // 0x0018(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ConstraintInstance
// 0x01B8
struct FConstraintInstance
{
unsigned char UnknownData_U95E[0x18]; // 0x0000(0x0018) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName JointName; // 0x0018(0x0008) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ConstraintBone1; // 0x0020(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ConstraintBone2; // 0x0028(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Pos1; // 0x0030(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector PriAxis1; // 0x003C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector SecAxis1; // 0x0048(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Pos2; // 0x0054(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector PriAxis2; // 0x0060(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector SecAxis2; // 0x006C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator AngularRotationOffset; // 0x0078(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
unsigned char bScaleLinearLimits : 1; // 0x0084(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_GVSM[0x7]; // 0x0085(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FConstraintProfileProperties ProfileInstance; // 0x008C(0x0104) (Edit, NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_IVU6[0x28]; // 0x0190(0x0028) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CullDistanceSizePair
// 0x0008
struct FCullDistanceSizePair
{
float Size; // 0x0000(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CullDistance; // 0x0004(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RuntimeCurveLinearColor
// 0x0208
struct FRuntimeCurveLinearColor
{
struct FRichCurve ColorCurves[0x4]; // 0x0000(0x0200) (NativeAccessSpecifierPublic)
class UCurveLinearColor* ExternalCurve; // 0x0200(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NamedCurveValue
// 0x000C
struct FNamedCurveValue
{
struct FName Name; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Value; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.DataTableCategoryHandle
// 0x0018
struct FDataTableCategoryHandle
{
class UDataTable* DataTable; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ColumnName; // 0x0008(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName RowContents; // 0x0010(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.DebugCameraControllerSettingsViewModeIndex
// 0x0010
struct FDebugCameraControllerSettingsViewModeIndex
{
unsigned char UnknownData_2AMT[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<EViewModeIndex> ViewModeIndex; // 0x0008(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_J18Z[0x7]; // 0x0009(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.DebugDisplayProperty
// 0x0020
struct FDebugDisplayProperty
{
class UObject* Obj; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UClass* WithinClass; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_RAVT[0x10]; // 0x0010(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MulticastRecordOptions
// 0x0018
struct FMulticastRecordOptions
{
struct FString FuncPathName; // 0x0000(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bServerSkip; // 0x0010(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bClientSkip; // 0x0011(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_R6ND[0x6]; // 0x0012(0x0006) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.RollbackNetStartupActorInfo
// 0x00A0
struct FRollbackNetStartupActorInfo
{
unsigned char UnknownData_F1ZH[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UObject* Archetype; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VDK4[0x18]; // 0x0010(0x0018) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class ULevel* Level; // 0x0028(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_H4ZA[0x60]; // 0x0030(0x0060) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<class UObject*> ObjReferences; // 0x0090(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LevelNameAndTime
// 0x0018
struct FLevelNameAndTime
{
struct FString LevelName; // 0x0000(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint32_t LevelChangeTimeInMS; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_5QTB[0x4]; // 0x0014(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.DialogueContext
// 0x0018
struct FDialogueContext
{
class UDialogueVoice* Speaker; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<class UDialogueVoice*> Targets; // 0x0008(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.DialogueWaveParameter
// 0x0020
struct FDialogueWaveParameter
{
class UDialogueWave* DialogueWave; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FDialogueContext Context; // 0x0008(0x0018) (Edit, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.DialogueContextMapping
// 0x0038
struct FDialogueContextMapping
{
struct FDialogueContext Context; // 0x0000(0x0018) (Edit, NativeAccessSpecifierPublic)
class USoundWave* SoundWave; // 0x0018(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString LocalizationKeyFormat; // 0x0020(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UDialogueSoundWaveProxy* Proxy; // 0x0030(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StatColorMapEntry
// 0x0008
struct FStatColorMapEntry
{
float In; // 0x0000(0x0004) (ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FColor Out; // 0x0004(0x0004) (ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StatColorMapping
// 0x0028
struct FStatColorMapping
{
struct FString StatName; // 0x0000(0x0010) (ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FStatColorMapEntry> ColorMap; // 0x0010(0x0010) (ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
unsigned char DisableBlend : 1; // 0x0020(0x0001) BIT_FIELD (Config, GlobalConfig, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_0COF[0x7]; // 0x0021(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.GraphReference
// 0x0020
struct FGraphReference
{
class UEdGraph* MacroGraph; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class UBlueprint* GraphBlueprint; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
struct FGuid GraphGuid; // 0x0010(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
};
// ScriptStruct Engine.GameNameRedirect
// 0x0010
struct FGameNameRedirect
{
struct FName OldGameName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName NewGameName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EdGraphPinReference
// 0x0018
struct FEdGraphPinReference
{
TWeakObjectPtr<class UEdGraphNode> OwningNode; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
struct FGuid PinId; // 0x0008(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.ClassRedirect
// 0x003C
struct FClassRedirect
{
struct FName ObjectName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName OldClassName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName NewClassName; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName OldSubobjName; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName NewSubobjName; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName NewClassClass; // 0x0028(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName NewClassPackage; // 0x0030(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool InstanceOnly; // 0x0038(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_STYR[0x3]; // 0x0039(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PluginRedirect
// 0x0020
struct FPluginRedirect
{
struct FString OldPluginName; // 0x0000(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString NewPluginName; // 0x0010(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EdGraphSchemaAction
// 0x0100
struct FEdGraphSchemaAction
{
unsigned char UnknownData_S8BU[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FText MenuDescription; // 0x0008(0x0018) (NativeAccessSpecifierPrivate)
struct FText TooltipDescription; // 0x0020(0x0018) (NativeAccessSpecifierPrivate)
struct FText Category; // 0x0038(0x0018) (NativeAccessSpecifierPrivate)
struct FText Keywords; // 0x0050(0x0018) (NativeAccessSpecifierPrivate)
int Grouping; // 0x0068(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int SectionID; // 0x006C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FString> MenuDescriptionArray; // 0x0070(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FString> FullSearchTitlesArray; // 0x0080(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FString> FullSearchKeywordsArray; // 0x0090(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FString> FullSearchCategoryArray; // 0x00A0(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FString> LocalizedMenuDescriptionArray; // 0x00B0(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FString> LocalizedFullSearchTitlesArray; // 0x00C0(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FString> LocalizedFullSearchKeywordsArray; // 0x00D0(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FString> LocalizedFullSearchCategoryArray; // 0x00E0(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
struct FString SearchText; // 0x00F0(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EdGraphSchemaAction_NewNode
// 0x0008 (0x0108 - 0x0100)
struct FEdGraphSchemaAction_NewNode : public FEdGraphSchemaAction
{
class UEdGraphNode* NodeTemplate; // 0x0100(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.StructRedirect
// 0x0010
struct FStructRedirect
{
struct FName OldStructName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName NewStructName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ScreenMessageString
// 0x0030
struct FScreenMessageString
{
uint64_t Key; // 0x0000(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString ScreenMessage; // 0x0008(0x0010) (ZeroConstructor, Transient, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FColor DisplayColor; // 0x0018(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TimeToDisplay; // 0x001C(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CurrentTimeDisplayed; // 0x0020(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D TextScale; // 0x0024(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_OMXJ[0x4]; // 0x002C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.DropNoteInfo
// 0x0028
struct FDropNoteInfo
{
struct FVector Location; // 0x0000(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x000C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FString Comment; // 0x0018(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.URL
// 0x0068
struct FURL
{
struct FString Protocol; // 0x0000(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString Host; // 0x0010(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int Port; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int Valid; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString Map; // 0x0028(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString RedirectURL; // 0x0038(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FString> Op; // 0x0048(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
struct FString Portal; // 0x0058(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FullyLoadedPackagesInfo
// 0x0038
struct FFullyLoadedPackagesInfo
{
TEnumAsByte<EFullyLoadPackageType> FullyLoadType; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_HOHQ[0x7]; // 0x0001(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FString Tag; // 0x0008(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FName> PackagesToLoad; // 0x0018(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<class UObject*> LoadedObjects; // 0x0028(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LevelStreamingStatus
// 0x0010
struct FLevelStreamingStatus
{
struct FName PackageName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bShouldBeLoaded : 1; // 0x0008(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bShouldBeVisible : 1; // 0x0008(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_6NKZ[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
uint32_t LODIndex; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NetDriverDefinition
// 0x0018
struct FNetDriverDefinition
{
struct FName DefName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName DriverClassName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName DriverClassNameFallback; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NamedNetDriver
// 0x0010
struct FNamedNetDriver
{
class UNetDriver* NetDriver; // 0x0000(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_0SMP[0x8]; // 0x0008(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.WorldContext
// 0x0280
struct FWorldContext
{
unsigned char UnknownData_B84B[0xD0]; // 0x0000(0x00D0) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FURL LastURL; // 0x00D0(0x0068) (NativeAccessSpecifierPublic)
struct FURL LastRemoteURL; // 0x0138(0x0068) (NativeAccessSpecifierPublic)
class UPendingNetGame* PendingNetGame; // 0x01A0(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FFullyLoadedPackagesInfo> PackagesToFullyLoad; // 0x01A8(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_QT2P[0x10]; // 0x01B8(0x0010) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<class ULevel*> LoadedLevelsForPendingMapChange; // 0x01C8(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_SIVV[0x18]; // 0x01D8(0x0018) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<class UObjectReferencer*> ObjectReferencers; // 0x01F0(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FLevelStreamingStatus> PendingLevelStreamingStatusUpdates; // 0x0200(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
class UGameViewportClient* GameViewport; // 0x0210(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UGameInstance* OwningGameInstance; // 0x0218(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FNamedNetDriver> ActiveNetDrivers; // 0x0220(0x0010) (ZeroConstructor, Transient, NativeAccessSpecifierPublic)
unsigned char UnknownData_DHYW[0x50]; // 0x0230(0x0050) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ExposureSettings
// 0x0008
struct FExposureSettings
{
float FixedEV100; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bFixed; // 0x0004(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_B0Q4[0x3]; // 0x0005(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TickPrerequisite
// 0x0010
struct FTickPrerequisite
{
unsigned char UnknownData_HQ2Q[0x10]; // 0x0000(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CanvasUVTri
// 0x0060
struct FCanvasUVTri
{
struct FVector2D V0_Pos; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D V0_UV; // 0x0008(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor V0_Color; // 0x0010(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D V1_Pos; // 0x0020(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D V1_UV; // 0x0028(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor V1_Color; // 0x0030(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D V2_Pos; // 0x0040(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D V2_UV; // 0x0048(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor V2_Color; // 0x0050(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.DepthFieldGlowInfo
// 0x0024
struct FDepthFieldGlowInfo
{
unsigned char bEnableGlow : 1; // 0x0000(0x0001) BIT_FIELD (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_HJPU[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FLinearColor GlowColor; // 0x0004(0x0010) (BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D GlowOuterRadius; // 0x0014(0x0008) (BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector2D GlowInnerRadius; // 0x001C(0x0008) (BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FontRenderInfo
// 0x0028
struct FFontRenderInfo
{
unsigned char bClipText : 1; // 0x0000(0x0001) BIT_FIELD (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableShadow : 1; // 0x0000(0x0001) BIT_FIELD (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EAD4[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FDepthFieldGlowInfo GlowInfo; // 0x0004(0x0024) (BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.Redirector
// 0x0010
struct FRedirector
{
struct FName OldName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName NewName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CollectionReference
// 0x0008
struct FCollectionReference
{
struct FName CollectionName; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ComponentReference
// 0x0028
struct FComponentReference
{
class AActor* OtherActor; // 0x0000(0x0008) (Edit, ZeroConstructor, DisableEditOnTemplate, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ComponentProperty; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString PathToComponent; // 0x0010(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_TH18[0x8]; // 0x0020(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ConstrainComponentPropName
// 0x0008
struct FConstrainComponentPropName
{
struct FName ComponentName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.POV
// 0x001C
struct FPOV
{
struct FVector Location; // 0x0000(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x000C(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
float FOV; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimUpdateRateParameters
// 0x0090
struct FAnimUpdateRateParameters
{
unsigned char UnknownData_3WMY[0x1]; // 0x0000(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
EUpdateRateShiftBucket ShiftBucket; // 0x0001(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bInterpolateSkippedFrames : 1; // 0x0002(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bShouldUseLodMap : 1; // 0x0002(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bShouldUseMinLod : 1; // 0x0002(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSkipUpdate : 1; // 0x0002(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSkipEvaluation : 1; // 0x0002(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_YYX9[0x1]; // 0x0003(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int UpdateRate; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int EvaluationRate; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TickedPoseOffestTime; // 0x000C(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AdditionalTime; // 0x0010(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_BRHV[0x4]; // 0x0014(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int BaseNonRenderedUpdateRate; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MaxEvalRateForInterpolation; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<float> BaseVisibleDistanceFactorThesholds; // 0x0020(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TMap<int, int> LODToFrameSkipMap; // 0x0030(0x0050) (ZeroConstructor, NativeAccessSpecifierPublic)
int SkippedUpdateFrames; // 0x0080(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int SkippedEvalFrames; // 0x0084(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseFixedEvalRate : 1; // 0x0088(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_3UO4[0x3]; // 0x0089(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int FixedEvalRate; // 0x008C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimSlotDesc
// 0x000C
struct FAnimSlotDesc
{
struct FName SlotName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int NumChannels; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.AnimSlotInfo
// 0x0018
struct FAnimSlotInfo
{
struct FName SlotName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<float> ChannelWeights; // 0x0008(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MTDResult
// 0x0010
struct FMTDResult
{
struct FVector Direction; // 0x0000(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float distance; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.OverlapResult
// 0x0018
struct FOverlapResult
{
TWeakObjectPtr<class AActor> Actor; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TWeakObjectPtr<class UPrimitiveComponent> Component; // 0x0008(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Z026[0x4]; // 0x0010(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bBlockingHit : 1; // 0x0014(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_BST3[0x3]; // 0x0015(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PrimitiveMaterialRef
// 0x0018
struct FPrimitiveMaterialRef
{
class UPrimitiveComponent* Primitive; // 0x0000(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UDecalComponent* Decal; // 0x0008(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ElementIndex; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_H0XT[0x4]; // 0x0014(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SwarmDebugOptions
// 0x0004
struct FSwarmDebugOptions
{
unsigned char bDistributionEnabled : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bForceContentExport : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bInitialized : 1; // 0x0000(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Z94P[0x3]; // 0x0001(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LightmassDebugOptions
// 0x0010
struct FLightmassDebugOptions
{
unsigned char bDebugMode : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bStatsEnabled : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGatherBSPSurfacesAcrossComponents : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_F9AY[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float CoplanarTolerance; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseImmediateImport : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bImmediateProcessMappings : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSortMappings : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bDumpBinaryFiles : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bDebugMaterials : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bPadMappings : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bDebugPaddings : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOnlyCalcDebugTexelMappings : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseRandomColors : 1; // 0x0009(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bColorBordersGreen : 1; // 0x0009(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bColorByExecutionTime : 1; // 0x0009(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Z12W[0x2]; // 0x000A(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float ExecutionTimeDivisor; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LightmassPrimitiveSettings
// 0x0018
struct FLightmassPrimitiveSettings
{
unsigned char bUseTwoSidedLighting : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bShadowIndirectOnly : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseEmissiveForStaticLighting : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseVertexNormalForHemisphereGather : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ITB0[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float EmissiveLightFalloffExponent; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float EmissiveLightExplicitInfluenceRadius; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float EmissiveBoost; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DiffuseBoost; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FullyOccludedSamplesFraction; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LightmassLightSettings
// 0x000C
struct FLightmassLightSettings
{
float IndirectLightingSaturation; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ShadowExponent; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bUseAreaShadowsForStationaryLight; // 0x0008(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_NYJZ[0x3]; // 0x0009(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LightmassDirectionalLightSettings
// 0x0004 (0x0010 - 0x000C)
struct FLightmassDirectionalLightSettings : public FLightmassLightSettings
{
float LightSourceAngle; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LightmassPointLightSettings
// 0x0000 (0x000C - 0x000C)
struct FLightmassPointLightSettings : public FLightmassLightSettings
{
};
// ScriptStruct Engine.BasedPosition
// 0x0038
struct FBasedPosition
{
class AActor* Base; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Position; // 0x0008(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector CachedBaseLocation; // 0x0014(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator CachedBaseRotation; // 0x0020(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FVector CachedTransPosition; // 0x002C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FractureEffect
// 0x0010
struct FFractureEffect
{
class UParticleSystem* ParticleSystem; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class USoundBase* Sound; // 0x0008(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RigidBodyContactInfo
// 0x0030
struct FRigidBodyContactInfo
{
struct FVector ContactPosition; // 0x0000(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector ContactNormal; // 0x000C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ContactPenetration; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_NVN0[0x4]; // 0x001C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UPhysicalMaterial* PhysMaterial[0x2]; // 0x0020(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CollisionImpactData
// 0x0028
struct FCollisionImpactData
{
TArray<struct FRigidBodyContactInfo> ContactInfos; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
struct FVector TotalNormalImpulse; // 0x0010(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector TotalFrictionImpulse; // 0x001C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RigidBodyErrorCorrection
// 0x0034
struct FRigidBodyErrorCorrection
{
float PingExtrapolation; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PingLimit; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ErrorPerLinearDifference; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ErrorPerAngularDifference; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxRestoredStateError; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxLinearHardSnapDistance; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PositionLerp; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AngleLerp; // 0x001C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LinearVelocityCoefficient; // 0x0020(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AngularVelocityCoefficient; // 0x0024(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ErrorAccumulationSeconds; // 0x0028(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ErrorAccumulationDistanceSq; // 0x002C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ErrorAccumulationSimilarity; // 0x0030(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RigidBodyState
// 0x0040
struct FRigidBodyState
{
struct FVector_NetQuantize100 Position; // 0x0000(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_XZW7[0x4]; // 0x000C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FQuat Quaternion; // 0x0010(0x0010) (IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FVector_NetQuantize100 LinVel; // 0x0020(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantize100 AngVel; // 0x002C(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char Flags; // 0x0038(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_51MF[0x7]; // 0x0039(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MaterialShadingModelField
// 0x0002
struct FMaterialShadingModelField
{
uint16_t ShadingModelField; // 0x0000(0x0002) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.ExponentialHeightFogData
// 0x000C
struct FExponentialHeightFogData
{
float FogDensity; // 0x0000(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FogHeightFalloff; // 0x0004(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FogHeightOffset; // 0x0008(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FontCharacter
// 0x0018
struct FFontCharacter
{
int StartU; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int StartV; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int USize; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int VSize; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char TextureIndex; // 0x0010(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_CWVE[0x3]; // 0x0011(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int VerticalOffset; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FontImportOptionsData
// 0x00B0
struct FFontImportOptionsData
{
struct FString FontName; // 0x0000(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Height; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableAntialiasing : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableBold : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableItalic : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableUnderline : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAlphaOnly : 1; // 0x0014(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_0V6U[0x3]; // 0x0015(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<EFontImportCharacterSet> CharacterSet; // 0x0018(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_KZCX[0x7]; // 0x0019(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FString Chars; // 0x0020(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString UnicodeRange; // 0x0030(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString CharsFilePath; // 0x0040(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString CharsFileWildcard; // 0x0050(0x0010) (Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCreatePrintableOnly : 1; // 0x0060(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIncludeASCIIRange : 1; // 0x0060(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_BM3O[0x3]; // 0x0061(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FLinearColor ForegroundColor; // 0x0064(0x0010) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableDropShadow : 1; // 0x0074(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_RHIV[0x3]; // 0x0075(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int TexturePageWidth; // 0x0078(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int TexturePageMaxHeight; // 0x007C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int XPadding; // 0x0080(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int YPadding; // 0x0084(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ExtendBoxTop; // 0x0088(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ExtendBoxBottom; // 0x008C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ExtendBoxRight; // 0x0090(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ExtendBoxLeft; // 0x0094(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bEnableLegacyMode : 1; // 0x0098(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_112Y[0x3]; // 0x0099(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int Kerning; // 0x009C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseDistanceFieldAlpha : 1; // 0x00A0(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_5ZUV[0x3]; // 0x00A1(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int DistanceFieldScaleFactor; // 0x00A4(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DistanceFieldScanRadiusScale; // 0x00A8(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_IJJB[0x4]; // 0x00AC(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ForceFeedbackAttenuationSettings
// 0x0000 (0x00B0 - 0x00B0)
struct FForceFeedbackAttenuationSettings : public FBaseAttenuationSettings
{
};
// ScriptStruct Engine.ForceFeedbackChannelDetails
// 0x0090
struct FForceFeedbackChannelDetails
{
unsigned char bAffectsLeftLarge : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAffectsLeftSmall : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAffectsRightLarge : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bAffectsRightSmall : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_6JLI[0x7]; // 0x0001(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FRuntimeFloatCurve Curve; // 0x0008(0x0088) (Edit, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PredictProjectilePathPointData
// 0x001C
struct FPredictProjectilePathPointData
{
struct FVector Location; // 0x0000(0x000C) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Velocity; // 0x000C(0x000C) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Time; // 0x0018(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PredictProjectilePathResult
// 0x00B8
struct FPredictProjectilePathResult
{
TArray<struct FPredictProjectilePathPointData> PathData; // 0x0000(0x0010) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, NativeAccessSpecifierPublic)
struct FPredictProjectilePathPointData LastTraceDestination; // 0x0010(0x001C) (Edit, BlueprintVisible, BlueprintReadOnly, EditConst, NoDestructor, NativeAccessSpecifierPublic)
struct FHitResult HitResult; // 0x002C(0x0088) (Edit, BlueprintVisible, BlueprintReadOnly, EditConst, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
unsigned char UnknownData_HX8E[0x4]; // 0x00B4(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PredictProjectilePathParams
// 0x0060
struct FPredictProjectilePathParams
{
struct FVector StartLocation; // 0x0000(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector LaunchVelocity; // 0x000C(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bTraceWithCollision; // 0x0018(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_JBR5[0x3]; // 0x0019(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float ProjectileRadius; // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxSimTime; // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bTraceWithChannel; // 0x0024(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ECollisionChannel> TraceChannel; // 0x0025(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_OAN0[0x2]; // 0x0026(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes; // 0x0028(0x0010) (Edit, BlueprintVisible, ZeroConstructor, AdvancedDisplay, NativeAccessSpecifierPublic)
TArray<class AActor*> ActorsToIgnore; // 0x0038(0x0010) (Edit, BlueprintVisible, ZeroConstructor, AdvancedDisplay, NativeAccessSpecifierPublic)
float SimFrequency; // 0x0048(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OverrideGravityZ; // 0x004C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EDrawDebugTrace> DrawDebugType; // 0x0050(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_A7HA[0x3]; // 0x0051(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float DrawDebugTime; // 0x0054(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bTraceComplex; // 0x0058(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_AKMB[0x7]; // 0x0059(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ActiveHapticFeedbackEffect
// 0x0018
struct FActiveHapticFeedbackEffect
{
class UHapticFeedbackEffect_Base* HapticEffect; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_PBTT[0x10]; // 0x0008(0x0010) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.HapticFeedbackDetails_Curve
// 0x0110
struct FHapticFeedbackDetails_Curve
{
struct FRuntimeFloatCurve Frequency; // 0x0000(0x0088) (Edit, NativeAccessSpecifierPublic)
struct FRuntimeFloatCurve Amplitude; // 0x0088(0x0088) (Edit, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ClusterNode
// 0x0040
struct FClusterNode
{
struct FVector BoundMin; // 0x0000(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int FirstChild; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector BoundMax; // 0x0010(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LastChild; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int FirstInstance; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LastInstance; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector MinInstanceScale; // 0x0028(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector MaxInstanceScale; // 0x0034(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ClusterNode_DEPRECATED
// 0x0028
struct FClusterNode_DEPRECATED
{
struct FVector BoundMin; // 0x0000(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int FirstChild; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector BoundMax; // 0x0010(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LastChild; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int FirstInstance; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int LastInstance; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.HLODProxyMesh
// 0x0030
struct FHLODProxyMesh
{
TLazyObjectPtr<class ALODActor> LODActor; // 0x0000(0x001C) (Edit, EditConst, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_PURI[0x4]; // 0x001C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UStaticMesh* StaticMesh; // 0x0020(0x0008) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
struct FName Key; // 0x0028(0x0008) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.SoundModulation
// 0x0010
struct FSoundModulation
{
TArray<class USoundModulationPluginSourceSettingsBase*> Settings; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ImportanceTexture
// 0x0050
struct FImportanceTexture
{
struct FIntPoint Size; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int NumMips; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_1PMG[0x4]; // 0x000C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<float> MarginalCDF; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<float> ConditionalCDF; // 0x0020(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FColor> TextureData; // 0x0030(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
TWeakObjectPtr<class UTexture2D> Texture; // 0x0040(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EImportanceWeight> Weighting; // 0x0048(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_2OWD[0x7]; // 0x0049(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ComponentKey
// 0x0020
struct FComponentKey
{
class UClass* OwnerClass; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
struct FName SCSVariableName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
struct FGuid AssociatedGuid; // 0x0010(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.ComponentOverrideRecord
// 0x0080
struct FComponentOverrideRecord
{
class UClass* ComponentClass; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UActorComponent* ComponentTemplate; // 0x0008(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FComponentKey ComponentKey; // 0x0010(0x0020) (NoDestructor, NativeAccessSpecifierPublic)
struct FBlueprintCookedComponentInstancingData CookedComponentInstancingData; // 0x0030(0x0050) (NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BlueprintInputDelegateBinding
// 0x0004
struct FBlueprintInputDelegateBinding
{
unsigned char bConsumeInput : 1; // 0x0000(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bExecuteWhenPaused : 1; // 0x0000(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverrideParentBinding : 1; // 0x0000(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EZCH[0x3]; // 0x0001(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BlueprintInputActionDelegateBinding
// 0x0014 (0x0018 - 0x0004)
struct FBlueprintInputActionDelegateBinding : public FBlueprintInputDelegateBinding
{
struct FName InputActionName; // 0x0004(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EInputEvent> InputKeyEvent; // 0x000C(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_BOCV[0x3]; // 0x000D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName FunctionNameToBind; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BlueprintInputAxisDelegateBinding
// 0x0010 (0x0014 - 0x0004)
struct FBlueprintInputAxisDelegateBinding : public FBlueprintInputDelegateBinding
{
struct FName InputAxisName; // 0x0004(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName FunctionNameToBind; // 0x000C(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BlueprintInputAxisKeyDelegateBinding
// 0x0024 (0x0028 - 0x0004)
struct FBlueprintInputAxisKeyDelegateBinding : public FBlueprintInputDelegateBinding
{
unsigned char UnknownData_L6KP[0x4]; // 0x0004(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FKey AxisKey; // 0x0008(0x0018) (HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName FunctionNameToBind; // 0x0020(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CachedKeyToActionInfo
// 0x0070
struct FCachedKeyToActionInfo
{
class UPlayerInput* PlayerInput; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Q8JV[0x68]; // 0x0008(0x0068) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BlueprintInputKeyDelegateBinding
// 0x0034 (0x0038 - 0x0004)
struct FBlueprintInputKeyDelegateBinding : public FBlueprintInputDelegateBinding
{
unsigned char UnknownData_OPOH[0x4]; // 0x0004(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FInputChord InputChord; // 0x0008(0x0020) (HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EInputEvent> InputKeyEvent; // 0x0028(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_YCGN[0x3]; // 0x0029(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName FunctionNameToBind; // 0x002C(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_CDTE[0x4]; // 0x0034(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BlueprintInputTouchDelegateBinding
// 0x000C (0x0010 - 0x0004)
struct FBlueprintInputTouchDelegateBinding : public FBlueprintInputDelegateBinding
{
TEnumAsByte<EInputEvent> InputKeyEvent; // 0x0004(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_H3OS[0x3]; // 0x0005(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName FunctionNameToBind; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InstancedStaticMeshLightMapInstanceData
// 0x0040
struct FInstancedStaticMeshLightMapInstanceData
{
struct FTransform Transform; // 0x0000(0x0030) (IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
TArray<struct FGuid> MapBuildDataIds; // 0x0030(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InstancedStaticMeshInstanceData
// 0x0040
struct FInstancedStaticMeshInstanceData
{
struct FMatrix Transform; // 0x0000(0x0040) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InstancedStaticMeshComponentInstanceData
// 0x0088 (0x0130 - 0x00A8)
struct FInstancedStaticMeshComponentInstanceData : public FSceneComponentInstanceData
{
class UStaticMesh* StaticMesh; // 0x00A8(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FInstancedStaticMeshLightMapInstanceData CachedStaticLighting; // 0x00B0(0x0040) (NativeAccessSpecifierPublic)
TArray<struct FInstancedStaticMeshInstanceData> PerInstanceSMData; // 0x00F0(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_OW0C[0x20]; // 0x0100(0x0020) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int InstancingRandomSeed; // 0x0120(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_EQX2[0xC]; // 0x0124(0x000C) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.InstancedStaticMeshMappingInfo
// 0x0008
struct FInstancedStaticMeshMappingInfo
{
unsigned char UnknownData_B21X[0x8]; // 0x0000(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.IntegralKey
// 0x0008
struct FIntegralKey
{
float Time; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int Value; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.IntegralCurve
// 0x0018 (0x0080 - 0x0068)
struct FIntegralCurve : public FIndexedCurve
{
TArray<struct FIntegralKey> Keys; // 0x0068(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
int DefaultValue; // 0x0078(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
bool bUseDefaultValueBeforeFirstKey; // 0x007C(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_BA3Z[0x3]; // 0x007D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CurveEdEntry
// 0x0038
struct FCurveEdEntry
{
class UObject* CurveObject; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FColor CurveColor; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_DZGI[0x4]; // 0x000C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FString CurveName; // 0x0010(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int bHideCurve; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int bColorCurve; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int bFloatingPointColorCurve; // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int bClamp; // 0x002C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ClampLow; // 0x0030(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ClampHigh; // 0x0034(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CurveEdTab
// 0x0030
struct FCurveEdTab
{
struct FString TabName; // 0x0000(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FCurveEdEntry> Curves; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
float ViewStartInput; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ViewEndInput; // 0x0024(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ViewStartOutput; // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ViewEndOutput; // 0x002C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InterpEdSelKey
// 0x0018
struct FInterpEdSelKey
{
class UInterpGroup* Group; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UInterpTrack* Track; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int KeyIndex; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float UnsnappedPosition; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CameraPreviewInfo
// 0x0030
struct FCameraPreviewInfo
{
class UClass* PawnClass; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UAnimSequence* AnimSeq; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Location; // 0x0010(0x000C) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FRotator Rotation; // 0x001C(0x000C) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
class APawn* PawnInst; // 0x0028(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SubTrackGroup
// 0x0028
struct FSubTrackGroup
{
struct FString GroupName; // 0x0000(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<int> TrackIndices; // 0x0010(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
unsigned char bIsCollapsed : 1; // 0x0020(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bIsSelected : 1; // 0x0020(0x0001) BIT_FIELD (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_TQKG[0x7]; // 0x0021(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.SupportedSubTrackInfo
// 0x0020
struct FSupportedSubTrackInfo
{
class UClass* SupportedClass; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString SubTrackName; // 0x0008(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int GroupIndex; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_AYPV[0x4]; // 0x001C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.AnimControlTrackKey
// 0x0020
struct FAnimControlTrackKey
{
float StartTime; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_GU5I[0x4]; // 0x0004(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UAnimSequence* AnimSeq; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AnimStartOffset; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AnimEndOffset; // 0x0014(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float AnimPlayRate; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLooping : 1; // 0x001C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bReverse : 1; // 0x001C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_8UIG[0x3]; // 0x001D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BoolTrackKey
// 0x0008
struct FBoolTrackKey
{
float Time; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char Value : 1; // 0x0004(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_CSBL[0x3]; // 0x0005(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.DirectorTrackCut
// 0x0014
struct FDirectorTrackCut
{
float Time; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float TransitionTime; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName TargetCamGroup; // 0x0008(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ShotNumber; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.EventTrackKey
// 0x000C
struct FEventTrackKey
{
float Time; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName EventName; // 0x0004(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InterpLookupPoint
// 0x000C
struct FInterpLookupPoint
{
struct FName GroupName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Time; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InterpLookupTrack
// 0x0010
struct FInterpLookupTrack
{
TArray<struct FInterpLookupPoint> Points; // 0x0000(0x0010) (ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ParticleReplayTrackKey
// 0x000C
struct FParticleReplayTrackKey
{
float Time; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Duration; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ClipIDNumber; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SoundTrackKey
// 0x0018
struct FSoundTrackKey
{
float Time; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Volume; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Pitch; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_C0A5[0x4]; // 0x000C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class USoundBase* Sound; // 0x0010(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ToggleTrackKey
// 0x0008
struct FToggleTrackKey
{
float Time; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ETrackToggleAction> ToggleAction; // 0x0004(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_I1O9[0x3]; // 0x0005(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.VisibilityTrackKey
// 0x0008
struct FVisibilityTrackKey
{
float Time; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EVisibilityTrackAction> Action; // 0x0004(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EVisibilityTrackCondition> ActiveCondition; // 0x0005(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_QU1W[0x2]; // 0x0006(0x0002) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.VectorSpringState
// 0x0018
struct FVectorSpringState
{
unsigned char UnknownData_DYWN[0x18]; // 0x0000(0x0018) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.FloatSpringState
// 0x0008
struct FFloatSpringState
{
unsigned char UnknownData_XHEB[0x8]; // 0x0000(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.DrawToRenderTargetContext
// 0x0010
struct FDrawToRenderTargetContext
{
class UTextureRenderTarget2D* RenderTarget; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_KD4C[0x8]; // 0x0008(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LatentActionManager
// 0x0060
struct FLatentActionManager
{
unsigned char UnknownData_KTD0[0x60]; // 0x0000(0x0060) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.LayerActorStats
// 0x0010
struct FLayerActorStats
{
class UClass* Type; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int Total; // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_4CT7[0x4]; // 0x000C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ReplicatedStaticActorDestructionInfo
// 0x0038
struct FReplicatedStaticActorDestructionInfo
{
unsigned char UnknownData_2JEK[0x30]; // 0x0000(0x0030) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UClass* ObjClass; // 0x0030(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LevelSimplificationDetails
// 0x0104
struct FLevelSimplificationDetails
{
bool bCreatePackagePerAsset; // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_OAB9[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float DetailsPercentage; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FMaterialProxySettings StaticMeshMaterialSettings; // 0x0008(0x0074) (Edit, NoDestructor, NativeAccessSpecifierPublic)
bool bOverrideLandscapeExportLOD; // 0x007C(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_57VY[0x3]; // 0x007D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int LandscapeExportLOD; // 0x0080(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FMaterialProxySettings LandscapeMaterialSettings; // 0x0084(0x0074) (Edit, NoDestructor, NativeAccessSpecifierPublic)
bool bBakeFoliageToLandscape; // 0x00F8(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bBakeGrassToLandscape; // 0x00F9(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bGenerateMeshNormalMap; // 0x00FA(0x0001) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bGenerateMeshMetallicMap; // 0x00FB(0x0001) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bGenerateMeshRoughnessMap; // 0x00FC(0x0001) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bGenerateMeshSpecularMap; // 0x00FD(0x0001) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bGenerateLandscapeNormalMap; // 0x00FE(0x0001) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bGenerateLandscapeMetallicMap; // 0x00FF(0x0001) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bGenerateLandscapeRoughnessMap; // 0x0100(0x0001) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bGenerateLandscapeSpecularMap; // 0x0101(0x0001) (ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_YXFO[0x2]; // 0x0102(0x0002) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.StreamableTextureInstance
// 0x0028
struct FStreamableTextureInstance
{
unsigned char UnknownData_A47N[0x28]; // 0x0000(0x0028) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.DynamicTextureInstance
// 0x0010 (0x0038 - 0x0028)
struct FDynamicTextureInstance : public FStreamableTextureInstance
{
class UTexture2D* Texture; // 0x0028(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAttached; // 0x0030(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_127I[0x3]; // 0x0031(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float OriginalRadius; // 0x0034(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PrecomputedLightInstanceData
// 0x0058 (0x0100 - 0x00A8)
struct FPrecomputedLightInstanceData : public FSceneComponentInstanceData
{
unsigned char UnknownData_J514[0x8]; // 0x00A8(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FTransform Transform; // 0x00B0(0x0030) (IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
struct FGuid LightGuid; // 0x00E0(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int PreviewShadowMapChannel; // 0x00F0(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_8HKA[0xC]; // 0x00F4(0x000C) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BatchedPoint
// 0x0028
struct FBatchedPoint
{
struct FVector Position; // 0x0000(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Color; // 0x000C(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PointSize; // 0x001C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float RemainingLifeTime; // 0x0020(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char DepthPriority; // 0x0024(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_O319[0x3]; // 0x0025(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.BatchedLine
// 0x0034
struct FBatchedLine
{
struct FVector Start; // 0x0000(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector End; // 0x000C(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FLinearColor Color; // 0x0018(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Thickness; // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float RemainingLifeTime; // 0x002C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char DepthPriority; // 0x0030(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_TYTY[0x3]; // 0x0031(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ClientReceiveData
// 0x0040
struct FClientReceiveData
{
class APlayerController* LocalPC; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName MessageType; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int MessageIndex; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_Y77S[0x4]; // 0x0014(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FString MessageString; // 0x0018(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class APlayerState* RelatedPlayerState_2; // 0x0028(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class APlayerState* RelatedPlayerState_3; // 0x0030(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UObject* OptionalObject; // 0x0038(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ParameterGroupData
// 0x0018
struct FParameterGroupData
{
struct FString GroupName; // 0x0000(0x0010) (Edit, ZeroConstructor, EditConst, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int GroupSortPriority; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_L1SG[0x4]; // 0x0014(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MaterialParameterCollectionInfo
// 0x0018
struct FMaterialParameterCollectionInfo
{
struct FGuid StateId; // 0x0000(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UMaterialParameterCollection* ParameterCollection; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MaterialFunctionInfo
// 0x0018
struct FMaterialFunctionInfo
{
struct FGuid StateId; // 0x0000(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UMaterialFunctionInterface* Function; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MaterialSpriteElement
// 0x0028
struct FMaterialSpriteElement
{
class UMaterialInterface* Material; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UCurveFloat* DistanceToOpacityCurve; // 0x0008(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSizeIsInScreenSpace : 1; // 0x0010(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_WMZX[0x3]; // 0x0011(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float BaseSizeX; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float BaseSizeY; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_KVCK[0x4]; // 0x001C(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UCurveFloat* DistanceToSizeCurve; // 0x0020(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ExpressionInput
// 0x000C
struct FExpressionInput
{
int OutputIndex; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ExpressionName; // 0x0004(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CustomInput
// 0x001C
struct FCustomInput
{
struct FName InputName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FExpressionInput Input; // 0x0008(0x000C) (NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_5K4J[0x8]; // 0x0014(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ExpressionOutput
// 0x0008
struct FExpressionOutput
{
struct FName OutputName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FunctionExpressionOutput
// 0x0020
struct FFunctionExpressionOutput
{
class UMaterialExpressionFunctionOutput* ExpressionOutput; // 0x0000(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid ExpressionOutputId; // 0x0008(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FExpressionOutput Output; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FunctionExpressionInput
// 0x0030
struct FFunctionExpressionInput
{
class UMaterialExpressionFunctionInput* ExpressionInput; // 0x0000(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid ExpressionInputId; // 0x0008(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FExpressionInput Input; // 0x0018(0x000C) (NoDestructor, NativeAccessSpecifierPublic)
unsigned char UnknownData_9Y1F[0xC]; // 0x0024(0x000C) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.FontParameterValue
// 0x0030
struct FFontParameterValue
{
struct FMaterialParameterInfo ParameterInfo; // 0x0000(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
class UFont* FontValue; // 0x0010(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int FontPage; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid ExpressionGUID; // 0x001C(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_4WUK[0x4]; // 0x002C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.TextureParameterValue
// 0x0028
struct FTextureParameterValue
{
struct FMaterialParameterInfo ParameterInfo; // 0x0000(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
class UTexture* ParameterValue; // 0x0010(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid ExpressionGUID; // 0x0018(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.VectorParameterValue
// 0x0030
struct FVectorParameterValue
{
struct FMaterialParameterInfo ParameterInfo; // 0x0000(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
struct FLinearColor ParameterValue; // 0x0010(0x0010) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid ExpressionGUID; // 0x0020(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ScalarParameterValue
// 0x0024
struct FScalarParameterValue
{
struct FMaterialParameterInfo ParameterInfo; // 0x0000(0x0010) (Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
float ParameterValue; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid ExpressionGUID; // 0x0014(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ScalarParameterAtlasInstanceData
// 0x0058
struct FScalarParameterAtlasInstanceData
{
bool bIsUsedAsAtlasPosition; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_UGAX[0x7]; // 0x0001(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char Curve[0x28]; // 0x0008(0x0028) UNKNOWN PROPERTY: SoftObjectProperty Engine.ScalarParameterAtlasInstanceData.Curve
unsigned char Atlas[0x28]; // 0x0030(0x0028) UNKNOWN PROPERTY: SoftObjectProperty Engine.ScalarParameterAtlasInstanceData.Atlas
};
// ScriptStruct Engine.MaterialInstanceBasePropertyOverrides
// 0x0008
struct FMaterialInstanceBasePropertyOverrides
{
unsigned char bOverride_OpacityMaskClipValue : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_BlendMode : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_ShadingModel : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_DitheredLODTransition : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_CastDynamicShadowAsMasked : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverride_TwoSided : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char TwoSided : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char DitheredLODTransition : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCastDynamicShadowAsMasked : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EBlendMode> BlendMode; // 0x0002(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EMaterialShadingModel> ShadingModel; // 0x0003(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OpacityMaskClipValue; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MaterialTextureInfo
// 0x0010
struct FMaterialTextureInfo
{
float SamplingScale; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int UVChannelIndex; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName TextureName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LightmassMaterialInterfaceSettings
// 0x0014
struct FLightmassMaterialInterfaceSettings
{
unsigned char bCastShadowAsMasked : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_MNJM[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float EmissiveBoost; // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DiffuseBoost; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ExportResolutionScale; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverrideCastShadowAsMasked : 1; // 0x0010(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverrideEmissiveBoost : 1; // 0x0010(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverrideDiffuseBoost : 1; // 0x0010(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bOverrideExportResolutionScale : 1; // 0x0010(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_ZXTX[0x3]; // 0x0011(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.CollectionParameterBase
// 0x0018
struct FCollectionParameterBase
{
struct FName ParameterName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FGuid ID; // 0x0008(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CollectionVectorParameter
// 0x0010 (0x0028 - 0x0018)
struct FCollectionVectorParameter : public FCollectionParameterBase
{
struct FLinearColor DefaultValue; // 0x0018(0x0010) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CollectionScalarParameter
// 0x0004 (0x001C - 0x0018)
struct FCollectionScalarParameter : public FCollectionParameterBase
{
float DefaultValue; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.InterpGroupActorInfo
// 0x0018
struct FInterpGroupActorInfo
{
struct FName ObjectName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<class AActor*> Actors; // 0x0008(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CameraCutInfo
// 0x0010
struct FCameraCutInfo
{
struct FVector Location; // 0x0000(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Timestamp; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.MemberReference
// 0x0038
struct FMemberReference
{
class UObject* MemberParent; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
struct FString MemberScope; // 0x0008(0x0010) (ZeroConstructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
struct FName MemberName; // 0x0018(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
struct FGuid MemberGuid; // 0x0020(0x0010) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
bool bSelfContext; // 0x0030(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
bool bWasDeprecated; // 0x0031(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
unsigned char UnknownData_L5MM[0x6]; // 0x0032(0x0006) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MeshInstancingSettings
// 0x0018
struct FMeshInstancingSettings
{
class UClass* ActorClassToUse; // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, NoClear, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int InstanceReplacementThreshold; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EMeshInstancingReplacementMethod MeshReplacementMethod; // 0x000C(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bSkipMeshesWithVertexColors; // 0x000D(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bUseHLODVolumes; // 0x000E(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_OW8S[0x1]; // 0x000F(0x0001) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UClass* ISMComponentToUse; // 0x0010(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PurchaseInfo
// 0x0040
struct FPurchaseInfo
{
struct FString Identifier; // 0x0000(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString DisplayName; // 0x0010(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString DisplayDescription; // 0x0020(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FString DisplayPrice; // 0x0030(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NameCurveKey
// 0x000C
struct FNameCurveKey
{
float Time; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName Value; // 0x0004(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NameCurve
// 0x0010 (0x0078 - 0x0068)
struct FNameCurve : public FIndexedCurve
{
TArray<struct FNameCurveKey> Keys; // 0x0068(0x0010) (Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NavAvoidanceMask
// 0x0004
struct FNavAvoidanceMask
{
unsigned char bGroup0 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup1 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup2 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup3 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup4 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup5 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup6 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup7 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup8 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup9 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup10 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup11 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup12 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup13 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup14 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup15 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup16 : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup17 : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup18 : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup19 : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup20 : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup21 : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup22 : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup23 : 1; // 0x0002(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup24 : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup25 : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup26 : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup27 : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup28 : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup29 : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup30 : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGroup31 : 1; // 0x0003(0x0001) BIT_FIELD (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NavDataConfig
// 0x0038 (0x0068 - 0x0030)
struct FNavDataConfig : public FNavAgentProperties
{
struct FName Name; // 0x0030(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FColor Color; // 0x0038(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector DefaultQueryExtent; // 0x003C(0x000C) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UClass* NavigationDataClass; // 0x0048(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FSoftClassPath NavigationDataClassName; // 0x0050(0x0018) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NavAgentSelector
// 0x0004
struct FNavAgentSelector
{
unsigned char bSupportsAgent0 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent1 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent2 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent3 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent4 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent5 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent6 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent7 : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent8 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent9 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent10 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent11 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent12 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent13 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent14 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent15 : 1; // 0x0001(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_R1EW[0x2]; // 0x0002(0x0002) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.NavigationLinkBase
// 0x0038
struct FNavigationLinkBase
{
float LeftProjectHeight; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxFallDownLength; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<ENavLinkDirection> Direction; // 0x0008(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_NNN3[0x7]; // 0x0009(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
float SnapRadius; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SnapHeight; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FNavAgentSelector SupportedAgents; // 0x0018(0x0004) (Edit, NoDestructor, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent0 : 1; // 0x001C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent1 : 1; // 0x001C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent2 : 1; // 0x001C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent3 : 1; // 0x001C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent4 : 1; // 0x001C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent5 : 1; // 0x001C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent6 : 1; // 0x001C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent7 : 1; // 0x001C(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent8 : 1; // 0x001D(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent9 : 1; // 0x001D(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent10 : 1; // 0x001D(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent11 : 1; // 0x001D(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent12 : 1; // 0x001D(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent13 : 1; // 0x001D(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent14 : 1; // 0x001D(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSupportsAgent15 : 1; // 0x001D(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VDRZ[0x2]; // 0x001E(0x0002) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bUseSnapHeight : 1; // 0x0020(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSnapToCheapestArea : 1; // 0x0020(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCustomFlag0 : 1; // 0x0020(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCustomFlag1 : 1; // 0x0020(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCustomFlag2 : 1; // 0x0020(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCustomFlag3 : 1; // 0x0020(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCustomFlag4 : 1; // 0x0020(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCustomFlag5 : 1; // 0x0020(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCustomFlag6 : 1; // 0x0021(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bCustomFlag7 : 1; // 0x0021(0x0001) BIT_FIELD (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_U0HX[0x6]; // 0x0022(0x0006) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UClass* AreaClass; // 0x0028(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
unsigned char UnknownData_V8N0[0x8]; // 0x0030(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.NavigationSegmentLink
// 0x0030 (0x0068 - 0x0038)
struct FNavigationSegmentLink : public FNavigationLinkBase
{
struct FVector LeftStart; // 0x0038(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector LeftEnd; // 0x0044(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector RightStart; // 0x0050(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector RightEnd; // 0x005C(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NavigationLink
// 0x0018 (0x0050 - 0x0038)
struct FNavigationLink : public FNavigationLinkBase
{
struct FVector Left; // 0x0038(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Right; // 0x0044(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ChannelDefinition
// 0x0028
struct FChannelDefinition
{
struct FName ChannelName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ClassName; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UClass* ChannelClass; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int StaticChannelIndex; // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bTickOnCreate; // 0x001C(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bServerOpen; // 0x001D(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bClientOpen; // 0x001E(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bInitialServer; // 0x001F(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bInitialClient; // 0x0020(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VZJZ[0x7]; // 0x0021(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PacketSimulationSettings
// 0x001C
struct FPacketSimulationSettings
{
int PktLoss; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int PktLossMaxSize; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int PktLossMinSize; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int PktOrder; // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int PktDup; // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int PktLag; // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int PktLagVariance; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.NodeItem
// 0x0040
struct FNodeItem
{
struct FName ParentName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_0JUV[0x8]; // 0x0008(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FTransform Transform; // 0x0010(0x0030) (IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ParticleBurst
// 0x000C
struct FParticleBurst
{
int Count; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int CountLow; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float Time; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ParticleRandomSeedInfo
// 0x0020
struct FParticleRandomSeedInfo
{
struct FName ParameterName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bGetSeedFromInstance : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bInstanceSeedIsIndex : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bResetSeedOnEmitterLooping : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bRandomlySelectSeedArray : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_VFDI[0x7]; // 0x0009(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<int> RandomSeeds; // 0x0010(0x0010) (Edit, ZeroConstructor, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ParticleCurvePair
// 0x0018
struct FParticleCurvePair
{
struct FString CurveName; // 0x0000(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UObject* CurveObject; // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.BeamModifierOptions
// 0x0004
struct FBeamModifierOptions
{
unsigned char bModify : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bScale : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bLock : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_2DO1[0x3]; // 0x0001(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.ParticleEvent_GenerateInfo
// 0x0028
struct FParticleEvent_GenerateInfo
{
TEnumAsByte<EParticleEventType> Type; // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_PFN7[0x3]; // 0x0001(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int Frequency; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int ParticleFrequency; // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char FirstTimeOnly : 1; // 0x000C(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char LastTimeOnly : 1; // 0x000C(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UseReflectedImpactVector : 1; // 0x000C(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseOrbitOffset : 1; // 0x000C(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_3UJ1[0x3]; // 0x000D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FName CustomName; // 0x0010(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<class UParticleModuleEventSendToGame*> ParticleModuleEventsToSendToGame; // 0x0018(0x0010) (Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.LocationBoneSocketInfo
// 0x0014
struct FLocationBoneSocketInfo
{
struct FName BoneSocketName; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector Offset; // 0x0008(0x000C) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.OrbitOptions
// 0x0004
struct FOrbitOptions
{
unsigned char bProcessDuringSpawn : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bProcessDuringUpdate : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseEmitterTime : 1; // 0x0000(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_E0UE[0x3]; // 0x0001(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.EmitterDynamicParameter
// 0x0050
struct FEmitterDynamicParameter
{
struct FName ParamName; // 0x0000(0x0008) (Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bUseEmitterTime : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char bSpawnTimeOnly : 1; // 0x0008(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_W3ET[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TEnumAsByte<EEmitterDynamicParameterValue> ValueMethod; // 0x000C(0x0001) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_W9G0[0x3]; // 0x000D(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
unsigned char bScaleVelocityByParamValue : 1; // 0x0010(0x0001) BIT_FIELD (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_21BL[0x7]; // 0x0011(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FRawDistributionFloat ParamValue; // 0x0018(0x0038) (Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.SubtitleCue
// 0x0020
struct FSubtitleCue
{
struct FText Text; // 0x0000(0x0018) (Edit, NativeAccessSpecifierPublic)
float Time; // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_8RLP[0x4]; // 0x001C(0x0004) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.InterpControlPoint
// 0x001C
struct FInterpControlPoint
{
struct FVector PositionControlPoint; // 0x0000(0x000C) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bPositionIsRelative; // 0x000C(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_7JO5[0xF]; // 0x000D(0x000F) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.UserActivity
// 0x0018
struct FUserActivity
{
struct FString ActionName; // 0x0000(0x0010) (BlueprintVisible, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_PRYZ[0x8]; // 0x0010(0x0008) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.GenericStruct
// 0x0004
struct FGenericStruct
{
int Data; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.CollisionProfileName
// 0x0008
struct FCollisionProfileName
{
struct FName Name; // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.TimerHandle
// 0x0008
struct FTimerHandle
{
uint64_t Handle; // 0x0000(0x0008) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
// ScriptStruct Engine.DebugFloatHistory
// 0x0020
struct FDebugFloatHistory
{
TArray<float> Samples; // 0x0000(0x0010) (ZeroConstructor, Transient, NativeAccessSpecifierPrivate)
float MaxSamples; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MinValue; // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MaxValue; // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAutoAdjustMinMax; // 0x001C(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_TH9K[0x3]; // 0x001D(0x0003) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.FormatArgumentData
// 0x0040
struct FFormatArgumentData
{
struct FString ArgumentName; // 0x0000(0x0010) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EFormatArgumentType> ArgumentValueType; // 0x0010(0x0001) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_XLGK[0x7]; // 0x0011(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FText ArgumentValue; // 0x0018(0x0018) (Edit, BlueprintVisible, DisableEditOnTemplate, NativeAccessSpecifierPublic)
int ArgumentValueInt; // 0x0030(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ArgumentValueFloat; // 0x0034(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
ETextGender ArgumentValueGender; // 0x0038(0x0001) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_SJ77[0x7]; // 0x0039(0x0007) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.MaterialInput
// 0x000C
struct FMaterialInput
{
int OutputIndex; // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FName ExpressionName; // 0x0004(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ScalarMaterialInput
// 0x0000 (0x000C - 0x000C)
struct FScalarMaterialInput : public FMaterialInput
{
};
// ScriptStruct Engine.VectorMaterialInput
// 0x0000 (0x000C - 0x000C)
struct FVectorMaterialInput : public FMaterialInput
{
};
// ScriptStruct Engine.ColorMaterialInput
// 0x0000 (0x000C - 0x000C)
struct FColorMaterialInput : public FMaterialInput
{
};
// ScriptStruct Engine.MaterialAttributesInput
// 0x0004 (0x0010 - 0x000C)
struct FMaterialAttributesInput : public FExpressionInput
{
int PropertyConnectedBitmask; // 0x000C(0x0004) (ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.ShadingModelMaterialInput
// 0x0000 (0x000C - 0x000C)
struct FShadingModelMaterialInput : public FMaterialInput
{
};
// ScriptStruct Engine.VectorDistribution
// 0x0028
struct FVectorDistribution
{
struct FDistributionLookupTable table; // 0x0000(0x0028) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.Vector4Distribution
// 0x0028
struct FVector4Distribution
{
struct FDistributionLookupTable table; // 0x0000(0x0028) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.FloatRK4SpringInterpolator
// 0x0008
struct FFloatRK4SpringInterpolator
{
float StiffnessConstant; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DampeningRatio; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.VectorRK4SpringInterpolator
// 0x0008
struct FVectorRK4SpringInterpolator
{
float StiffnessConstant; // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DampeningRatio; // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.Vector2MaterialInput
// 0x0000 (0x000C - 0x000C)
struct FVector2MaterialInput : public FMaterialInput
{
};
// ScriptStruct Engine.BranchingPointNotifyPayload
// 0x0020
struct FBranchingPointNotifyPayload
{
unsigned char UnknownData_5RO3[0x20]; // 0x0000(0x0020) MISSED OFFSET (PADDING)
};
// ScriptStruct Engine.PlatformInterfaceData
// 0x0030
struct FPlatformInterfaceData
{
struct FName DataName; // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TEnumAsByte<EPlatformInterfaceDataType> Type; // 0x0008(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_R5JU[0x3]; // 0x0009(0x0003) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
int IntValue; // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FloatValue; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_DSLS[0x4]; // 0x0014(0x0004) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FString StringValue; // 0x0018(0x0010) (ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UObject* ObjectValue; // 0x0028(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PlatformInterfaceDelegateResult
// 0x0038
struct FPlatformInterfaceDelegateResult
{
bool bSuccessful; // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
unsigned char UnknownData_7F8U[0x7]; // 0x0001(0x0007) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
struct FPlatformInterfaceData Data; // 0x0008(0x0030) (NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.DamageEvent
// 0x0010
struct FDamageEvent
{
unsigned char UnknownData_DQCK[0x8]; // 0x0000(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
class UClass* DamageTypeClass; // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RadialDamageParams
// 0x0014
struct FRadialDamageParams
{
float BaseDamage; // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float MinimumDamage; // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float InnerRadius; // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float OuterRadius; // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float DamageFalloff; // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.RadialDamageEvent
// 0x0030 (0x0040 - 0x0010)
struct FRadialDamageEvent : public FDamageEvent
{
struct FRadialDamageParams Params; // 0x0010(0x0014) (NoDestructor, NativeAccessSpecifierPublic)
struct FVector Origin; // 0x0024(0x000C) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FHitResult> ComponentHits; // 0x0030(0x0010) (ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
// ScriptStruct Engine.PointDamageEvent
// 0x0098 (0x00A8 - 0x0010)
struct FPointDamageEvent : public FDamageEvent
{
float Damage; // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FVector_NetQuantizeNormal ShotDirection; // 0x0014(0x000C) (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FHitResult HitInfo; // 0x0020(0x0088) (IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"noreply@github.com"
] | noreply@github.com |
a67467c6620a8d8b0d402349464da68b1ad678f5 | d16985a72e39109c30b1e975007cc1cabe8a6ac8 | /Server/Server/Item/ItemRuler.cpp | 449e304ea5675f24692b60ded13c13b7e4df9b45 | [] | no_license | uvbs/wx2Server | e878c3c5c27715a0a1044f6b3229960d36eff4b4 | 78a4b693ac018a4ae82e7919f6e29c97b92554ab | refs/heads/master | 2021-01-18T00:06:34.770227 | 2013-12-13T09:18:54 | 2013-12-13T09:18:54 | 43,288,843 | 2 | 3 | null | 2015-09-28T08:24:45 | 2015-09-28T08:24:44 | null | UTF-8 | C++ | false | false | 44,728 | cpp | /********************************************************************
创建日期: 2005年11月11日
创建时间: 16:35
文件名称: ItemRuler.cpp
文件路径: d:\Prj\Server\Server\Item\ItemRuler.cpp
创建人: 曾鹏翔
文件功能： 物品规则相关的维护
修改纪录：
*********************************************************************/
#include "stdafx.h"
#include "ItemRuler.h"
#include "ItemTable.h"
#include "Rand.h"
#include "GameDefine2.h"
#include "TimeManager.h"
#include "ItemHelper.h"
#include "GameTable.h"
#include "Obj_Human.h"
#include "Obj_Monster.h"
#include "ScanOperator_ActiveTeammates.h"
#include "Config.h"
#include "Scene.h"
#include "Obj_ItemManager.h"
#include "Obj_Item.h"
#include "LogDefine.h"
#include "SouXia.h"
VOID Obj_ItemRuler::CreateItemFromMonsterDrop(INT iMonsterID,
INT iPlayerLvl, //玩家级别
BOOL bTeam,
FLOAT fControlValue,
Obj_ItemContaner& OutContaner) //监控系数
{
__ENTER_FUNCTION
UINT dBaseDropRate; //基本掉落率
double dDeltaDropRate = 1.0; //级别修正率
UINT dCurrentRate; //当前掉落率随机数
MONSTER_EXT_ATTR *pAttr = g_MonsterAttrExTbl.GetExtAttr( iMonsterID );
Assert ( pAttr != NULL );
INT iMonsterType = pAttr->m_BossFlag;
INT iMonsterLvl = pAttr->m_Level;
UINT nTotalRand = RandGen::GetRand(0, 100);
if (nTotalRand>(UINT)pAttr->m_nMonsterDropRate)
{
return;
}
if(pAttr->m_MonsterDropItemSetID < 0)
{
return;
}
MONSTER_DROP_TB* pTb = g_ItemTable.GetMonsterDropTB(pAttr->m_MonsterDropItemSetID);
if(pTb)
{
if(pTb->m_ValidCount != 0)
{
DROP_ATT_TB* pDropAtt = g_ItemTable.GetDropAttTB(iPlayerLvl-iMonsterLvl);
if(pDropAtt)
{
if(bTeam)
{
dDeltaDropRate = pDropAtt->m_TeamAttValue;
}
else dDeltaDropRate = pDropAtt->m_AttValue;
}
else
return;
if((dDeltaDropRate == 0)||(g_Config.m_ConfigInfo.m_DropParam == 0))
return;
MONSTER_DROPCONTENT* pTbContent = pTb->m_Drops;
_ITEM it;
INT quality = 0;
ITEM_LOG_PARAM ItemLogParam;
_ITEM_TYPE itemType;
BOOL Ret = FALSE;
for(UINT j =0; j<pTb->m_ValidCount; ++j)
{
//生成这个物品掉落的概率 概率=物品价值*级别修正率*全局掉落修正参数
dBaseDropRate = (double)pTb->m_Drops[j].m_nItemValue*dDeltaDropRate*(double)g_Config.m_ConfigInfo.m_DropParam;
//获得当前掉落率随机数
dCurrentRate = RandGen::GetRand(0, MAX_MONSTER_VALUE);
if(dCurrentRate<=dBaseDropRate)
{
if(pTb->m_Drops[j].m_nItemCount > 0)
{
for(INT nNum=0; nNum<pTb->m_Drops[j].m_nCycle; ++nNum)
{
int nPos = RandGen::GetRand(0, pTb->m_Drops[j].m_nItemCount-1);
UINT uItemIndex = pTb->m_Drops[j].m_pDropContent[nPos];
UCHAR uClass = GetSerialClass(uItemIndex);
it.CleanUp();
switch(uClass)
{
case ICLASS_EQUIP:
{
EQUIP_TB* pGET = g_ItemTable.GetEquipTB(uItemIndex);
if(!pGET)
{
g_pLog->FastSaveLog( LOG_FILE_1, "找不到对应物品的表格定义，请确定EQUIP资源正确 ItemType=%d",uItemIndex);
OutContaner.CleanUp();
return;
}
itemType = ConvertSerial2ItemType(uItemIndex);
it.GetEquipData()->m_EquipType = ITEM_DROP;
Ret = ItemCreateRuler::CreateEquipAttrib(&ItemLogParam, itemType, 0, it, quality, iMonsterLvl, iMonsterType);
if (Ret)
{
if(g_pItemManager->GenItemGuid(it.m_ItemGUID))
{
OutContaner.AddItem(it);
}
}
}
break;
case ICLASS_MATERIAL:
{
COMMITEM_INFO_TB* pGET = g_ItemTable.GetCommItemInfoTB(uItemIndex);
if(!pGET)
{
g_pLog->FastSaveLog( LOG_FILE_1, "找不到对应物品的表格定义，请确定CommonItem资源正确 ItemType=%d",uItemIndex);
OutContaner.CleanUp();
return;
}
itemType = ConvertSerial2ItemType(uItemIndex);
Ret = ItemCreateRuler::CreateMedicAttrib(itemType, it);
if (Ret)
{
if(g_pItemManager->GenItemGuid(it.m_ItemGUID))
{
OutContaner.AddItem(it);
}
}
}
break;
case ICLASS_COMITEM:
case ICLASS_IDENT:
{
COMMITEM_INFO_TB* pGET = g_ItemTable.GetCommItemInfoTB(uItemIndex);
if(!pGET)
{
g_pLog->FastSaveLog( LOG_FILE_1, "找不到对应物品的表格定义，请确定CommonItem资源正确 ItemType=%d",uItemIndex);
OutContaner.CleanUp();
return;
}
itemType = ConvertSerial2ItemType(uItemIndex);
Ret = ItemCreateRuler::CreateMedicAttrib(itemType, it);
if (Ret)
{
if(g_pItemManager->GenItemGuid(it.m_ItemGUID))
{
OutContaner.AddItem(it);
}
}
}
break;
case ICLASS_GEM:
{
GEMINFO_TB* pGET = g_ItemTable.GetGemInfoTB(uItemIndex);
if(!pGET)
{
g_pLog->FastSaveLog( LOG_FILE_1, "找不到对应物品的表格定义，请确定Gem资源正确 ItemType=%d",uItemIndex);
OutContaner.CleanUp();
return;
}
itemType = ConvertSerial2ItemType(uItemIndex);
Ret = ItemCreateRuler::CreateGemAttrib(itemType, it);
if (Ret)
{
if(g_pItemManager->GenItemGuid(it.m_ItemGUID))
{
OutContaner.AddItem(it);
}
}
}
break;
default:
g_pLog->FastSaveLog( LOG_FILE_1, "找不到对应物品的类型 uClass=%d",uClass);
OutContaner.CleanUp();
return;
}
}
}
}
}
}
}
__LEAVE_FUNCTION
}
//创建装备属性
BOOL ItemCreateRuler::CreateEquipAttrib(ITEM_LOG_PARAM* pLogParam,_ITEM_TYPE itemType,
INT iPlayerJob,_ITEM& it,INT& quality, INT iMonsterLvl, INT iMonsterType)
{
__ENTER_FUNCTION
Assert(pLogParam);
EQUIP_TB* pGET = g_ItemTable.GetEquipTB(itemType.ToSerial());
if(pGET)
{
it.m_ItemIndex = pGET->m_IndexID;
it.m_RulerID = (CHAR)pGET->m_RulerID;
//it.GetEquipData()->m_EquipPoint = pGET->m_EquipPoint;
//it.GetEquipData()->m_SetNum = pGET->m_EquipSetNum; //牌型
it.GetEquipData()->m_BasePrice = pGET->m_BasePrice; //售出价格
//it.GetEquipData()->m_EquipPoint = pGET->m_EquipPoint; //物品装佩点
it.GetEquipData()->m_MaxDurPoint = pGET->m_MaxDur; //最大耐久值
//it.GetEquipData()->m_NeedLevel = pGET->m_ReqLevel; //需求等级
it.GetEquipData()->m_BaseGemHole = pGET->m_BaseGemHole; //最大宝石个数
//it.GetEquipData()->m_MAXGemHole = pGET->m_MAXGemHole; //最大镶嵌孔
//it.GetEquipData()->m_PrefessionReq = pGET->m_PrefessionReq; //职业需求
//it.GetEquipData()->m_MaxNum = pGET->m_EquipSetMaxNum; //最大套装数目
//it.GetEquipData()->m_AttrCount = pGET->m_AttCount; //属性的数量
//it.GetEquipData()->m_nAffixSkillCount = pGET->m_AffSkillCount; //附加技能个数
//it.GetEquipData()->m_nEffectSkillCount = pGET->m_EffSkillCount; //装备影响技能个数
it.GetEquipData()->m_CurDamagePoint = 0;
INT nAttCount = 0;
if(pGET->m_NearAttack>0)
{
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = IATTRIBUTE_BASE_ATTACK_NEAR; //近程攻击
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = pGET->m_NearAttack; //近程攻击
++nAttCount;
}
if(pGET->m_FarAttack>0)
{
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = IATTRIBUTE_BASE_ATTACK_FAR; //远程攻击
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = pGET->m_FarAttack; //远程攻击
++nAttCount;
}
if(pGET->m_MagicNearAttack>0)
{
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = IATTRIBUTE_BASE_ATTACK_MAGIC_NEAR; //近程内功攻击
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = pGET->m_MagicNearAttack; //近程内功攻击
++nAttCount;
}
if(pGET->m_MagicFarAttack>0)
{
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = IATTRIBUTE_BASE_ATTACK_MAGIC_FAR;//近程外功攻击
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = pGET->m_MagicFarAttack; //近程外功攻击
++nAttCount;
}
if(pGET->m_NearDefence>0)
{
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = IATTRIBUTE_BASE_DEFENCE_NEAR; //近程防御
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = pGET->m_NearDefence; //近程防御
++nAttCount;
}
if(pGET->m_FarDefence>0)
{
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = IATTRIBUTE_BASE_DEFENCE_FAR; //远程防御
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = pGET->m_FarDefence; //远程防御
++nAttCount;
}
if(pGET->m_MagicNearDefense>0)
{
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = IATTRIBUTE_BASE_DEFENCE_MAGIC_NEAR;//近程内功防御
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = pGET->m_MagicNearDefense; //近程内功防御
++nAttCount;
}
if(pGET->m_MagicFarDefense>0)
{
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = IATTRIBUTE_BASE_DEFENCE_MAGIC_FAR;//近程外功防御
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = pGET->m_MagicFarDefense; //近程外功防御
++nAttCount;
}
it.GetEquipData()->m_PaiType = pGET->m_PaiType;
it.GetEquipData()->m_CurDurPoint = pGET->m_MaxDur;
it.GetEquipData()->m_CurMaxDur = pGET->m_MaxDur;
it.GetEquipData()->m_CurGemHole = pGET->m_BaseGemHole;
it.GetEquipData()->m_AttrCount = nAttCount;
Assert(pGET->m_ReqLevelCount>0);
INT nNeedLevel = pGET->m_ReqLevel[0];
if(pGET->m_ReqLevelCount > 1)
{
INT nRand = RandGen::GetRand(0, pGET->m_ReqLevelCount-1);
nNeedLevel = pGET->m_ReqLevel[nRand];
}
it.GetEquipData()->m_NeedLevel = nNeedLevel; //需要等级
if((HUMAN_EQUIP)pGET->m_EquipPoint == HEQUIP_SUIT)
{
memcpy(&it.GetEquipData()->m_pAttr[nAttCount], &pGET->m_Attr, sizeof(_ITEM_ATTR)*pGET->m_AttCount);
it.GetEquipData()->m_AttrCount += pGET->m_AttCount;
return TRUE;
}
// add by gh for souxia 捜侠录道具和坐骑没有影响
if (HEQUIP_SOUXIA == (HUMAN_EQUIP)pGET->m_EquipPoint || HEQUIP_RIDER == (HUMAN_EQUIP)pGET->m_EquipPoint)
{
return TRUE;
}
// end of add
if(it.GetEquipData()->m_EquipType == ITEM_DROP)
{
return CaculateDropEquipEffectAttrib(pLogParam, it, iPlayerJob, iMonsterLvl, iMonsterType);
}
else if(it.GetEquipData()->m_EquipType == ITEM_CREATE)
{
return CaculateCreateEquipEffectAttrib(pLogParam, it, iPlayerJob);
}
return CaculateEquipEffectAttrib(pLogParam, it, iPlayerJob);
}
Assert(FALSE);
__LEAVE_FUNCTION
return FALSE;
}
//---------------------------------------------------------------------------------------------*/
BOOL ItemCreateRuler::CreateGemAttrib(_ITEM_TYPE itemType,_ITEM& it)
{
__ENTER_FUNCTION
GEMINFO_TB* pGET = g_ItemTable.GetGemInfoTB( itemType.ToSerial());
if(pGET)
{
it.m_ItemIndex = pGET->m_nTableIndex;
it.m_RulerID = (CHAR)pGET->m_nRulerID;
it.GetGemData()->m_nPrice = pGET->m_nPrice;
it.GetGemData()->m_nSellPrice = pGET->m_nSellPrice;
it.GetGemData()->m_bBroadCast = pGET->m_bBroadCast;
memcpy(it.GetGemData()->m_EquipType, pGET->m_EquipType, sizeof(UINT)*MAX_BASE_EQUIP_COUNT);
it.GetGemData()->m_AttCount = pGET->m_AttCount;
for(UINT i=0; i<it.GetGemData()->m_AttCount; ++i)
{
it.GetGemData()->m_GenAttr[i].m_AttrType = pGET->m_GenAttr[i].m_AttrType;
it.GetGemData()->m_GenAttr[i].m_Value.m_Value = pGET->m_GenAttr[i].m_Value.m_Value;
}
it.GetGemData()->m_GemReqCount = pGET->m_GemReqCount;
for(UINT i=0; i<it.GetGemData()->m_GemReqCount; ++i)
{
it.GetGemData()->m_GemReqAttr[i].m_GemType = pGET->m_GemReqAttr[i].m_GemType;
it.GetGemData()->m_GemReqAttr[i].m_Value.m_Value = pGET->m_GemReqAttr[i].m_Value.m_Value;
}
return TRUE;
}
else
g_pLog->FastSaveLog( LOG_FILE_1,
"ItemCreateRuler::CreateEquipAttrib can't find GEMINFO_TB GemObjID =%d", itemType.ToSerial() ) ;
return FALSE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CreateGemAttrib(UINT TableIndex,_ITEM& it)
{
__ENTER_FUNCTION
GEMINFO_TB* pGET = g_ItemTable.GetGemInfoTB( TableIndex);
if(pGET)
{
it.m_ItemIndex = pGET->m_nTableIndex;
it.m_RulerID = (CHAR)pGET->m_nRulerID;
it.GetGemData()->m_nPrice = pGET->m_nPrice;
it.GetGemData()->m_nSellPrice = pGET->m_nSellPrice;
it.GetGemData()->m_bBroadCast = pGET->m_bBroadCast;
memcpy(it.GetGemData()->m_EquipType, pGET->m_EquipType, sizeof(MAX_BASE_EQUIP_COUNT));
it.GetGemData()->m_AttCount = pGET->m_AttCount;
for(UINT i=0; i<it.GetGemData()->m_AttCount; ++i)
{
it.GetGemData()->m_GenAttr[i].m_AttrType = pGET->m_GenAttr[i].m_AttrType;
it.GetGemData()->m_GenAttr[i].m_Value.m_Value = pGET->m_GenAttr[i].m_Value.m_Value;
}
it.GetGemData()->m_GemReqCount = pGET->m_GemReqCount;
for(UINT i=0; i<it.GetGemData()->m_GemReqCount; ++i)
{
it.GetGemData()->m_GemReqAttr[i].m_GemType = pGET->m_GemReqAttr[i].m_GemType;
it.GetGemData()->m_GemReqAttr[i].m_Value.m_Value = pGET->m_GemReqAttr[i].m_Value.m_Value;
}
return TRUE;
}
else
g_pLog->FastSaveLog( LOG_FILE_1, "ItemCreateRuler::CreateGemAttrib can't find GEMINFO_TB GemObjID =%d", TableIndex ) ;
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CreateMaterialAttrib(_ITEM_TYPE itemType,_ITEM& it)
{
__ENTER_FUNCTION
Assert(FALSE);
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CreateMedicAttrib(_ITEM_TYPE itemType,_ITEM& it)
{
__ENTER_FUNCTION
COMMITEM_INFO_TB* pGET = g_ItemTable.GetCommItemInfoTB( itemType.ToSerial());
if(pGET)
{
it.m_ItemIndex = pGET->m_nTableIndex;
it.GetMedicData()->m_nLevel = pGET->m_nLevel;
it.GetMedicData()->m_nBasePrice = pGET->m_nBasePrice;
it.GetMedicData()->m_nSellPrice = pGET->m_nSellPrice;
it.m_RulerID = (CHAR)pGET->m_nRulerID;
it.GetMedicData()->m_nLayedNum = pGET->m_nLayedNum;
it.GetMedicData()->m_nScriptID = pGET->m_nScriptID;
it.GetMedicData()->m_nSkillID = pGET->m_nSkillID;
it.GetMedicData()->m_nCount = 1; //叠放物品，产生一个
it.GetMedicData()->m_nReqSkill = pGET->m_nReqSkill;
it.GetMedicData()->m_nReqSkillLevel = pGET->m_nReqSkillLevel;
it.GetMedicData()->m_TargetType = pGET->m_TargetType;
it.GetMedicData()->m_bBroadcast = pGET->m_bBroadcast;
// add by gh for souxia 2010/05/11
if (COMITEM_SOUXIA == itemType.m_Type)
{
return CreateSouXiaAttrib(itemType, it);
}
return TRUE;
}
else
Assert(FALSE);
return FALSE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CreateTaskItemAttrib(_ITEM_TYPE itemType,_ITEM& it)
{
__ENTER_FUNCTION
TASKITEM_INFO_TB* pGET = g_ItemTable.GetTaskItemInfoTB( itemType.ToSerial());
if(pGET)
{
it.m_ItemIndex = pGET->m_nTableIndex;
it.GetMedicData()->m_nLevel = pGET->m_nLevel;
it.GetMedicData()->m_nBasePrice = pGET->m_nBasePrice;
it.GetMedicData()->m_nSellPrice = pGET->m_nSellPrice;
it.m_RulerID = (CHAR)pGET->m_nRulerID;
it.GetMedicData()->m_nLayedNum = pGET->m_nLayedNum;
it.GetMedicData()->m_nScriptID = pGET->m_nScriptID;
it.GetMedicData()->m_nSkillID = pGET->m_nSkillID;
it.GetMedicData()->m_nCount = 1; //叠放物品，产生一个
it.GetMedicData()->m_nReqSkill = pGET->m_nReqSkill;
it.GetMedicData()->m_nReqSkillLevel = pGET->m_nReqSkillLevel;
it.GetMedicData()->m_TargetType = pGET->m_TargetType;
it.GetMedicData()->m_bBroadcast = pGET->m_bBroadcast;
return TRUE;
}
else
Assert(FALSE);
return FALSE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CreateExtraBagAttrib(_ITEM_TYPE itemType,_ITEM& it)
{
__ENTER_FUNCTION
EXTRABAG_INFO_TB* pGET = g_ItemTable.GetExtraBagInfoTB(itemType.ToSerial());
if(pGET)
{
it.m_ItemIndex = pGET->m_nTableIndex;
it.m_RulerID = (CHAR)pGET->m_nRulerID;
it.GetExtraBagData()->m_nBasePrice = pGET->m_nBasePrice;
it.GetExtraBagData()->m_nSellPrice = pGET->m_nSellPrice;
it.GetExtraBagData()->m_nValidTime = pGET->m_nValidTime;
it.GetExtraBagData()->m_nBeginTime = INVALID_TIME;
it.GetExtraBagData()->m_nSize = pGET->m_nSize;
return TRUE;
}
else
Assert(FALSE);
return FALSE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CreateMountAttrib(_ITEM_TYPE itemType,_ITEM& it) // [7/8/2010 陈军龙]
{
__ENTER_FUNCTION
MOUNT_INFO_TB* pGET = g_ItemTable.GetMountInfoTB(itemType.ToSerial());
if(pGET)
{
it.m_ItemIndex = pGET->m_nTableIndex;
it.m_RulerID = (CHAR)pGET->m_nRule;
it.GetMountData()->m_nNeedLevel = pGET->m_nNeedLevel;
it.GetMountData()->m_nAddtionSpeed = pGET->m_nAddtionSpeed;
it.GetMountData()->m_nLife = pGET->m_nLife;
it.GetMountData()->m_nBindType = pGET->m_nBindType;
it.GetMountData()->m_nPrice = pGET->m_nPrice;
return TRUE;
}
else
Assert(FALSE);
return FALSE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CreateStoreMapAttrib(_ITEM_TYPE itemType,_ITEM& it)
{
__ENTER_FUNCTION
STORE_MAP_INFO_TB* pGET = g_ItemTable.GetStoreMapTB(itemType.ToSerial());
if(pGET)
{
it.m_ItemIndex = pGET->m_nTableIndex;
//it.m_ItemType = pGET->m_ItemType;
it.GetStoreMapData()->m_nLevel = pGET->m_nLevel;
it.m_RulerID = (CHAR)pGET->m_nRulerID;
it.GetStoreMapData()->m_xPos = pGET->m_xPos;
it.GetStoreMapData()->m_zPos = pGET->m_zPos;
it.GetStoreMapData()->m_SceneID = pGET->m_SceneID;
it.GetStoreMapData()->m_GrowType = pGET->m_GrowPointType;
return TRUE;
}
else
Assert(FALSE);
return FALSE;
__LEAVE_FUNCTION
return FALSE;
}
// add by gh
BOOL ItemCreateRuler::CreateSouXiaAttrib(_ITEM_TYPE itemType, _ITEM& it)
{
__ENTER_FUNCTION
SOUXIA_INFO_TB* pGET = g_ItemTable.GetSouXiaTB(itemType.ToSerial());
if(pGET)
{
it.m_ItemIndex = pGET->m_nTableIndex;
if (ITEM_SOUXIALU == pGET->m_nUseType)
{
it.m_Param[0] = pGET->m_nTableIndex;
}
else if(ITEM_MEMORYCLUB == pGET->m_nUseType )
{
for (int i=0; i<4; ++i)
{
if (pGET->m_nMemoryContent[i] > 0)
{
it.m_Param[2] = pGET->m_nMemoryContent[i]; // 有可能是从表格随机的要通知客户端
}
}
}
return TRUE;
}
else
Assert(FALSE);
return FALSE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CreateSoulBeadAttrib(_ITEM_TYPE itemType,_ITEM& it)
{
__ENTER_FUNCTION
SOUL_BEAD_INFO_TB* pGET = g_ItemTable.GetSoulBeadTB(itemType.ToSerial());
if(pGET)
{
it.m_ItemIndex = pGET->m_nTableIndex;
it.m_RulerID = pGET->m_nRuleID;
//it.m_SoulBead.m_nSellPrice =
//it.m_SoulBead.m_nValidTime = pGET->m_nValidTime;
return TRUE;
}
else
Assert(FALSE);
return FALSE;
__LEAVE_FUNCTION
return FALSE;
}
// end of add
BOOL ItemCreateRuler::CreateQuestItemAttrib(_ITEM_TYPE itemType,_ITEM& it)
{
__ENTER_FUNCTION
return FALSE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CaculateDropEquipEffectAttrib(ITEM_LOG_PARAM* pLogParam,_ITEM& it,
INT iPlayerJob, INT iMonsterLvl, INT iMonsterType)
{
__ENTER_FUNCTION
Assert(pLogParam);
Assert(it.GetEquipData()->m_EquipType == ITEM_DROP);
EQUIP_TB* pGET = g_ItemTable.GetEquipTB(it.m_ItemIndex);
Assert(pGET);
if (!pGET)
{
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemCreateRuler::CaculateDropEquipEffectAttrib] GetEquipTB index is error [%d]",it.m_ItemIndex);
return FALSE;
}
UINT nPointValue = g_ItemTable.GetEquipPointValue((HUMAN_EQUIP)pGET->m_EquipPoint);
Assert(nPointValue != 0);
UINT nAddLevel = 0;
switch(iMonsterType)
{
case 0:
nAddLevel = g_Config.m_ConfigInfo.m_nComMonsterDrop;
break;
case 1:
nAddLevel = g_Config.m_ConfigInfo.m_nBossDrop;
break;
default:
Assert(0);
break;
}
INT nAttCount = it.GetEquipData()->m_AttrCount;
if(ISCommonEquip(it.m_ItemIndex))//普通装备
{
UINT nSumRate = g_ItemTable.GetSumRateByReqLevel(it.GetEquipData()->m_NeedLevel);
INT nSetCount = g_ItemTable.GetAttSetCount();
//属性组随机算法
INT nRand = RandGen::GetRand(0, nSumRate);
EQUIP_ATT_SET_TB* pSetTB = g_ItemTable.GetAttSetTBByRate(nRand);
if(pSetTB)
{
//it.GetEquipData()->m_nAttSet = pSetTB->m_IndexID;
for(int nEquipAttCount=0; nEquipAttCount<pSetTB->m_AttCount; ++nEquipAttCount)
{
EQUIP_ATT_LEVEL_TB* pLevelTB = g_ItemTable.GetAttLevelValue((ITEM_ATTRIBUTE)pSetTB->m_Attr[nEquipAttCount]);
if(pLevelTB)
{
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = pSetTB->m_Attr[nEquipAttCount];
float fValue = (float)pLevelTB->m_Attr[iMonsterLvl+nAddLevel]*(float)nPointValue/(float)100.0;
if (fValue<1)
{
fValue = 1;
}
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = (SHORT)fValue;
++nAttCount;
}
else
{
g_pLog->FastSaveLog( LOG_FILE_1, "ItemCreateRuler::CaculateDropEquipEffectAttrib can't find EQUIP_ATT_LEVEL_TB") ;
Assert(0);
}
}
it.GetEquipData()->m_AttrCount = it.GetEquipData()->m_AttrCount + nAttCount;
}
}
else
{
memcpy(&it.GetEquipData()->m_pAttr[nAttCount], &pGET->m_Attr, sizeof(_ITEM_ATTR)*pGET->m_AttCount);
it.GetEquipData()->m_AttrCount = it.GetEquipData()->m_AttrCount + pGET->m_AttCount;
}
it.GetEquipData()->m_EquipScore = pGET->m_EquipScore;
return TRUE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CaculateCreateEquipEffectAttrib(ITEM_LOG_PARAM* pLogParam,_ITEM& it, INT iPlayerJob)
{
__ENTER_FUNCTION
Assert(pLogParam);
Assert(it.GetEquipData()->m_EquipType == ITEM_CREATE);
Assert(it.GetEquipData()->m_EquipScore>0);
Assert(iPlayerJob >=0);
Assert(iPlayerJob <MAX_JOB_SUM);
EQUIP_TB* pGET = g_ItemTable.GetEquipTB(it.m_ItemIndex);
Assert(pGET);
if (!pGET)
{
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemCreateRuler::CaculateCreateEquipEffectAttrib] GetEquipTB index is error [%d]",it.m_ItemIndex);
return FALSE;
}
UINT nPointValue = g_ItemTable.GetEquipPointValue((HUMAN_EQUIP)pGET->m_EquipPoint);
Assert(nPointValue != 0);
if (it.GetEquipData()->m_EquipScore>(UINT)g_Config.m_ConfigInfo.m_nMinPaiScore)
{
if(it.GetEquipData()->m_EquipScore<(UINT)g_Config.m_ConfigInfo.m_nMinZiPaiScore)
{
UINT nCount = g_ItemTable.GetNoZiPaiCount();
if (nCount>0)
{
INT nRand = RandGen::GetRand(0, nCount-1);
it.GetEquipData()->m_PaiType = g_ItemTable.GetNoZiPai(nRand);
}
}
else
{
UINT nCount = g_ItemTable.GetZiPaiCount();
if (nCount>0)
{
INT nRand = RandGen::GetRand(0, nCount-1);
it.GetEquipData()->m_PaiType = g_ItemTable.GetZiPai(nRand);
}
}
}
INT nAttCount = it.GetEquipData()->m_AttrCount;
if (ISCommonEquip(it.m_ItemIndex))
{
EQUIPEXTRATT_TB* pEquipExtraAtt = g_ItemTable.GetEquipExtraAttInfoTB(it.GetEquipData()->m_EquipScore);
Assert(pEquipExtraAtt);
if (!pEquipExtraAtt)
{
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemCreateRuler::CaculateCreateEquipEffectAttrib] GetEquipExtraAttInfoTB index is error [%d]",it.GetEquipData()->m_EquipScore);
return FALSE;
}
EQUIPEXTRATT equipExtraAtt = pEquipExtraAtt->m_EquipExtrAtt[iPlayerJob];
INT nMaxValidNum = equipExtraAtt.m_ValidCount-1;
Assert(equipExtraAtt.m_ValidCount <= MAX_ITEM_NATUREATTR);
for (UINT i=0; i<equipExtraAtt.m_ValidCount; ++i)
{
UINT nAtt = RandGen::GetRand(0, equipExtraAtt.m_GenAttr[i].m_AttrCount-1);
EQUIP_ATT_LEVEL_TB* pAttTB = g_ItemTable.GetAttLevelValue((ITEM_ATTRIBUTE)equipExtraAtt.m_GenAttr[i].m_Attr[nAtt]);
Assert(pAttTB);
if (!pAttTB)
{
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemCreateRuler::CaculateCreateEquipEffectAttrib] GetAttLevelValue index is error [%d]",(ITEM_ATTRIBUTE)equipExtraAtt.m_GenAttr[i].m_Attr[nAtt]);
return FALSE;
}
UINT nValue = pAttTB->m_Attr[it.GetEquipData()->m_NeedLevel];
//基础数值*被选中的次数*装备分值加成。
double nLogScore = log((double)it.GetEquipData()->m_EquipScore);
double nDValue = (double)nValue*nPointValue*nLogScore/(double)100;
nValue = (UINT)nDValue;
if (nValue == 0)
{
nValue = 1;
}
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = equipExtraAtt.m_GenAttr[i].m_Attr[nAtt];
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = nValue;
++nAttCount;
}
it.GetEquipData()->m_AttrCount = nAttCount;
}
else
{
for (UINT i=0; i<pGET->m_AttCount; ++i)
{
SHORT nValue = pGET->m_Attr[i].m_Value.m_Value;
//基础数值*装备分值加成*装备权重。
double nLogScore = log((double)it.GetEquipData()->m_EquipScore);
float fValue = (float)nValue*(float)nLogScore;
if (fValue == 0)
{
fValue = 1;
}
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = pGET->m_Attr[i].m_AttrType;
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = nValue;
++nAttCount;
}
it.GetEquipData()->m_AttrCount = nAttCount;
}
return TRUE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL ItemCreateRuler::CaculateEquipEffectAttrib(ITEM_LOG_PARAM* pLogParam,_ITEM& it, INT iPlayerLvl)
{
__ENTER_FUNCTION
Assert(pLogParam);
Assert(it.GetEquipData()->m_EquipType != ITEM_DROP);
Assert(it.GetEquipData()->m_EquipType != ITEM_CREATE);
//Assert(!ISCommonEquip(it.m_ItemIndex)); //普通装备
EQUIP_TB* pGET = g_ItemTable.GetEquipTB(it.m_ItemIndex);
Assert(pGET);
if (!pGET)
{
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemCreateRuler::CaculateEquipEffectAttrib] GetEquipTB index is error [%d]",it.m_ItemIndex);
return FALSE;
}
UINT nPointValue = g_ItemTable.GetEquipPointValue((HUMAN_EQUIP)pGET->m_EquipPoint);
Assert(nPointValue != 0);
INT nAttCount = it.GetEquipData()->m_AttrCount;
if(ISCommonEquip(it.m_ItemIndex))//普通装备
{
UINT nSumRate = g_ItemTable.GetSumRateByReqLevel(it.GetEquipData()->m_NeedLevel);
INT nSetCount = g_ItemTable.GetAttSetCount();
//属性组随机算法
INT nRand = RandGen::GetRand(0, nSumRate);
EQUIP_ATT_SET_TB* pSetTB = g_ItemTable.GetAttSetTBByRate(nRand);
if(pSetTB)
{
//it.GetEquipData()->m_nAttSet = pSetTB->m_IndexID;
for(int nEquipAttCount=0; nEquipAttCount<pSetTB->m_AttCount; ++nEquipAttCount)
{
EQUIP_ATT_LEVEL_TB* pLevelTB = g_ItemTable.GetAttLevelValue((ITEM_ATTRIBUTE)pSetTB->m_Attr[nEquipAttCount]);
if(pLevelTB)
{
it.GetEquipData()->m_pAttr[nAttCount].m_AttrType = pSetTB->m_Attr[nEquipAttCount];
float fValue = (float)pLevelTB->m_Attr[it.GetEquipData()->m_NeedLevel]*(float)nPointValue/(float)100.0;
if (fValue<1)
{
fValue = 1;
}
it.GetEquipData()->m_pAttr[nAttCount].m_Value.m_Value = (SHORT)fValue;
++nAttCount;
}
else
{
g_pLog->FastSaveLog( LOG_FILE_1, "ItemCreateRuler::CaculateEquipEffectAttrib can't find EQUIP_ATT_LEVEL_TB") ;
Assert(0);
}
}
it.GetEquipData()->m_AttrCount = nAttCount;
}
}
else
{
memcpy(&it.GetEquipData()->m_pAttr[nAttCount], &pGET->m_Attr, sizeof(_ITEM_ATTR)*pGET->m_AttCount);
it.GetEquipData()->m_AttrCount = it.GetEquipData()->m_AttrCount + pGET->m_AttCount;
}
it.GetEquipData()->m_EquipScore = pGET->m_EquipScore;
return TRUE;
__LEAVE_FUNCTION
return FALSE;
}
//最小获取经验为1
uint MonsterExpCaculateRuler::CaculateBaseExp(INT iMonsterLevel,INT iKillerLevel,uint MonsterBaseExp, BOOL bTeam)
{
__ENTER_FUNCTION
DROP_ATT_TB* pDropAttTB = g_ItemTable.GetDropAttTB(iKillerLevel-iMonsterLevel);
Assert(pDropAttTB);
if (!pDropAttTB)
{
g_pLog->FastSaveLog( LOG_FILE_1, "[MonsterExpCaculateRuler::CaculateBaseExp] GetDropAttTB index is error [%d]",iKillerLevel-iMonsterLevel);
return 1;
}
UINT nExp = 0;
if (bTeam)
{
nExp = (uint)(MonsterBaseExp*pDropAttTB->m_TeamExpValue);
if (nExp == 0)
{
nExp = 1;
}
}
else
{
nExp = (uint)(MonsterBaseExp*pDropAttTB->m_ExpValue);
if (nExp == 0)
{
nExp = 1;
}
}
return nExp;
__LEAVE_FUNCTION
return 1 ;
}
BOX_DISTRIBUTE_RULER MonsterDropRuler::GetMonsterDropRuler(Obj_Monster* pMonster)
{
__ENTER_FUNCTION
Assert(pMonster);
INT iDataID = pMonster->GetDataID();
MONSTER_EXT_ATTR *pAttr = g_MonsterAttrExTbl.GetExtAttr( iDataID );
if(pAttr)
{
return (BOX_DISTRIBUTE_RULER)pAttr->m_BossFlag;
}
return BDR_UNKNOW;
__LEAVE_FUNCTION
return BDR_UNKNOW;
}
BOOL MonsterDropRuler::CaculateCommOwnerList(Obj_Monster* pMonster)
{
__ENTER_FUNCTION
if(!pMonster)
{
Assert(pMonster);
return FALSE;
}
Scene* pScene = pMonster->getScene();
if(!pScene)
{
Assert(pScene);
return FALSE;
}
DAMAGE_MEM_LIST DamageMemList = pMonster->GetKillerRec();
if (DamageMemList.m_uCount > 0)
{
for(UINT i=0; i<DamageMemList.m_uCount; ++i)
{
pMonster->GetOwnerList().AddOwner(DamageMemList.m_DamageRec[i].m_Killer, DamageMemList.m_DamageRec[i].m_KillerObjID);
}
}
return TRUE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL MonsterDropRuler::CaculateBossOwnerList(Obj_Monster* pMonster)
{
__ENTER_FUNCTION
if(!pMonster)
{
Assert(pMonster);
return FALSE;
}
Scene* pScene = pMonster->getScene();
if(!pScene)
{
Assert(pScene);
return FALSE;
}
DAMAGE_MEM_LIST DamageMemList = pMonster->GetKillerRec();
if (DamageMemList.m_uCount > 0)
{
for(UINT i=0; i<DamageMemList.m_uCount; ++i)
{
pMonster->GetOwnerList().AddOwner(DamageMemList.m_DamageRec[i].m_Killer, DamageMemList.m_DamageRec[i].m_KillerObjID);
}
}
return TRUE;
__LEAVE_FUNCTION
return FALSE;
}
#define MD_PICK_RANGE (100.0f)
BOOL MonsterDropRuler::CaculateCommDropRuler(Obj_Monster* pMonster, BOX_DISTRIBUTE_RULER DropRuler)
{
__ENTER_FUNCTION
if(!pMonster)
{
Assert(FALSE);
return FALSE;
}
Scene* pScene = pMonster->getScene();
if(!pScene)
{
Assert(pScene);
return FALSE;
}
Obj_ItemManager* pIBManager = pScene->GetObj_ItemManager();
Assert(pIBManager);
UINT iMonsterLevel = pMonster->GetLevel();
UINT iKillerLevel = pMonster->GetOccupantLevel();
INT iDataID = pMonster->GetDataID();
TeamID_t teamID = pMonster->GetOccupantTeamID();
BYTE nDistribMode = pMonster->GetDistribMode();
BYTE nLastOwnerPos = pMonster->GetLastOwnerPos() + 1;
GUID_t nTeamLeaderGuid = pMonster->GetOwnTeamLeader();
MONSTER_OWNER_LIST ownerList = pMonster->GetOwnerList();
FLOAT fSearchLength = pMonster->GetDropSearchRange();
INT nValidMemberCount = 0; // 有效范围内符合级别条件的玩家数量
INT nValidNewbieMemberCount = 0;
Obj_Human *apValidMember[MAX_TEAM_MEMBER];
BOOL bTeam = FALSE;
if(pMonster->GetOccupantTeamID() != INVALID_ID)
{
bTeam = TRUE;
if (nDistribMode == ITEM_INTURNS_DISTRIB)
{
Obj_Human* pHuman = NULL;
for( UINT i=0; i<ownerList.OwnerCount; i++ )
{
if ((ownerList.OwnerDropList[i].m_Guid != INVALID_ID)&&(ownerList.OwnerDropList[i].m_ObjID!=INVALID_ID))
{
pHuman = pScene->GetHumanManager()->GetHuman(ownerList.OwnerDropList[i].m_ObjID);
if (pHuman)
{
if (pHuman->GetGUID() == ownerList.OwnerDropList[i].m_Guid)
{
if (pHuman->IsInValidRadius( pMonster, fSearchLength ))
{
apValidMember[nValidMemberCount++] = pHuman;
}
}
}
}
}
}
}
Obj_ItemContaner IBContaner =
pIBManager->CaculateItemDropFromMonster(iKillerLevel,iDataID, bTeam);
//判断掉出物品数量是否小于0或大于最大值
if(IBContaner.m_nCount<=0)
{
ownerList.CleanUp();
return FALSE;
}
if(IBContaner.m_nCount>8)
{
ownerList.CleanUp();
return FALSE;
}
//物品掉落
WORLD_POS dropPos;
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_CREATE_FROM_MONSTER;
ItemLogParam.SceneID = pScene->SceneID();
ItemLogParam.NpcType = iDataID;
if(pMonster->GetOwnerList().OwnerCount >= 1)
{
for(INT m=0; m<IBContaner.m_nCount; ++m)
{
BOOL aLive = FALSE;
if(!pMonster->GetNearCanDropPos(dropPos))
{
return TRUE;
}
Obj_Item* pItem = pIBManager->CreateMonsterDropObj_Item(&dropPos, &IBContaner.m_Item[m]); //创建Item;
if (bTeam)
{
switch(nDistribMode)
{
case ITEM_FREE_DISTRIB:
{
for (UINT i=0; i<ownerList.OwnerCount; ++i)
{
pItem->SetOwner(ownerList.OwnerDropList[i].m_Guid);
}
}
break;
case ITEM_TEAMLEADER_DISTRIB:
{
if (pMonster->GetOwnerList().OwnerCount == 1)
{
pItem->SetOwner(ownerList.OwnerDropList[0].m_Guid);
}
else
{
pItem->SetOwner(nTeamLeaderGuid);
}
}
break;
case ITEM_INTURNS_DISTRIB:
{
if (pMonster->GetOwnerList().OwnerCount == 1)
{
pItem->SetOwner(ownerList.OwnerDropList[0].m_Guid);
}
else
{
if (nLastOwnerPos>=nValidMemberCount)
{
nLastOwnerPos = 0;
}
pItem->SetOwner(apValidMember[nLastOwnerPos]->GetGUID());
if (m == IBContaner.m_nCount-1)
{
for (INT i=0; i<nValidMemberCount; ++i)
{
TeamInfo* pTeamInfo = apValidMember[i]->GetTeamInfo();
pTeamInfo->SetLastOwnerPos(nLastOwnerPos);
}
}
++nLastOwnerPos;
}
}
break;
case ITEM_SEPARATE_DISTRIB:
{
pItem->SetOwner(ownerList.OwnerDropList[0].m_Guid);
}
break;
default:
Assert(0);
break;
}
}
else
{
for (UINT i=0; i<ownerList.OwnerCount; ++i)
{
pItem->SetOwner(ownerList.OwnerDropList[i].m_Guid);
}
}
pItem->SetDropObjID(pMonster->GetID());
pItem->SetActiveFlag(TRUE);
ItemLogParam.ItemGuid = pItem->GetObj_Item()->m_ItemGUID;
ItemLogParam.ItemType = pItem->GetObj_Item()->m_ItemIndex;
ItemLogParam.XPos = dropPos.m_fX;
ItemLogParam.ZPos = dropPos.m_fZ;
SaveItemLog(&ItemLogParam);
}
}
ownerList.CleanUp();
return TRUE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL MonsterDropRuler::CaculateBossDropRuler(Obj_Monster* pMonster, BOX_DISTRIBUTE_RULER DropRuler)
{
__ENTER_FUNCTION
if(!pMonster)
{
Assert(FALSE);
return FALSE;
}
Scene* pScene = pMonster->getScene();
if(!pScene)
{
Assert(pScene);
return FALSE;
}
Obj_ItemManager* pIBManager = pScene->GetObj_ItemManager();
Assert(pIBManager);
UINT iMonsterLevel = pMonster->GetLevel();
UINT iKillerLevel = pMonster->GetOccupantLevel();
INT iDataID = pMonster->GetDataID();
TeamID_t teamID = pMonster->GetOccupantTeamID();
BYTE nDistribMode = pMonster->GetDistribMode();
BYTE nLastOwnerPos = pMonster->GetLastOwnerPos() + 1;
GUID_t nTeamLeaderGuid = pMonster->GetOwnTeamLeader();
MONSTER_OWNER_LIST ownerList = pMonster->GetOwnerList();
FLOAT fSearchLength = pMonster->GetDropSearchRange();
INT nValidMemberCount = 0; // 有效范围内符合级别条件的玩家数量
INT nValidNewbieMemberCount = 0;
Obj_Human *apValidMember[MAX_TEAM_MEMBER];
BOOL bTeam = FALSE;
if(pMonster->GetOccupantTeamID() != INVALID_ID)
{
bTeam = TRUE;
if (nDistribMode == ITEM_INTURNS_DISTRIB)
{
Obj_Human* pHuman = NULL;
for( UINT i=0; i<ownerList.OwnerCount; i++ )
{
if ((ownerList.OwnerDropList[i].m_Guid != INVALID_ID)&&(ownerList.OwnerDropList[i].m_ObjID!=INVALID_ID))
{
pHuman = pScene->GetHumanManager()->GetHuman(ownerList.OwnerDropList[i].m_ObjID);
if (pHuman)
{
if (pHuman->GetGUID() == ownerList.OwnerDropList[i].m_Guid)
{
if (pHuman->IsInValidRadius( pMonster, fSearchLength ))
{
apValidMember[nValidMemberCount++] = pHuman;
}
}
}
}
}
}
}
Obj_ItemContaner IBContaner =
pIBManager->CaculateItemDropFromMonster(iKillerLevel,iDataID, bTeam);
//判断掉出物品数量是否小于0或大于最大值
if(IBContaner.m_nCount<=0)
{
ownerList.CleanUp();
return FALSE;
}
if(IBContaner.m_nCount>100)
{
return FALSE;
}
//物品掉落
WORLD_POS dropPos;
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_CREATE_FROM_MONSTER;
ItemLogParam.SceneID = pScene->SceneID();
ItemLogParam.NpcType = iDataID;
if(pMonster->GetOwnerList().OwnerCount >= 1)
{
for(INT m=0; m<IBContaner.m_nCount; ++m)
{
BOOL aLive = FALSE;
if(!pMonster->GetNearCanDropPos(dropPos))
{
return TRUE;
}
Obj_Item* pItem = pIBManager->CreateMonsterDropObj_Item(&dropPos, &IBContaner.m_Item[m]); //创建Item;
if (bTeam)
{
switch(nDistribMode)
{
case ITEM_FREE_DISTRIB:
{
for (UINT i=0; i<ownerList.OwnerCount; ++i)
{
pItem->SetOwner(ownerList.OwnerDropList[i].m_Guid);
}
}
break;
case ITEM_TEAMLEADER_DISTRIB:
{
if (pMonster->GetOwnerList().OwnerCount == 1)
{
pItem->SetOwner(ownerList.OwnerDropList[0].m_Guid);
}
else
{
pItem->SetOwner(nTeamLeaderGuid);
}
}
break;
case ITEM_INTURNS_DISTRIB:
{
if (pMonster->GetOwnerList().OwnerCount == 1)
{
pItem->SetOwner(ownerList.OwnerDropList[0].m_Guid);
}
else
{
if (nLastOwnerPos>=nValidMemberCount)
{
nLastOwnerPos = 0;
}
pItem->SetOwner(apValidMember[nLastOwnerPos]->GetGUID());
if (m == IBContaner.m_nCount-1)
{
for (INT i=0; i<nValidMemberCount; ++i)
{
TeamInfo* pTeamInfo = apValidMember[i]->GetTeamInfo();
pTeamInfo->SetLastOwnerPos(nLastOwnerPos);
}
}
++nLastOwnerPos;
}
}
break;
case ITEM_SEPARATE_DISTRIB:
{
pItem->SetOwner(ownerList.OwnerDropList[0].m_Guid);
}
break;
default:
Assert(0);
break;
}
}
else
{
for (UINT i=0; i<ownerList.OwnerCount; ++i)
{
pItem->SetOwner(ownerList.OwnerDropList[i].m_Guid);
}
}
pItem->SetDropObjID(pMonster->GetID());
pItem->SetActiveFlag(TRUE);
ItemLogParam.ItemGuid = pItem->GetObj_Item()->m_ItemGUID;
ItemLogParam.ItemType = pItem->GetObj_Item()->m_ItemIndex;
ItemLogParam.XPos = dropPos.m_fX;
ItemLogParam.ZPos = dropPos.m_fZ;
SaveItemLog(&ItemLogParam);
}
}
ownerList.CleanUp();
return TRUE;
__LEAVE_FUNCTION
return FALSE;
}
//--------------------------------------------------------------------------------------------------------
BOOL ItemRulerCheck::CheckTypeRuler(ITEM_RULER_LIST ruler,const UINT uItemIndex)
{
__ENTER_FUNCTION
Assert(uItemIndex!=0);
Assert(uItemIndex!=INVALID_ID);
UCHAR uClass = GetSerialClass(uItemIndex);
switch(uClass)
{
case ICLASS_EQUIP:
{
EQUIP_TB* pGET = g_ItemTable.GetEquipTB(uItemIndex);
if(!pGET)
{
CHAR Buff[255];
memset(Buff,0,255);
sprintf(Buff,"找不到对应物品的表格定义，请确定装备资源正确 ItemType=%d",uItemIndex);
AssertEx(pGET,Buff);
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemRulerCheck::CheckTypeRuler] GetEquipTB index is error [%d]",uItemIndex);
return FALSE;
}
return CheckRuler(ruler,pGET->m_RulerID);
}
break;
case ICLASS_MATERIAL:
case ICLASS_COMITEM:
case ICLASS_IDENT:
{
COMMITEM_INFO_TB* pGET = g_ItemTable.GetCommItemInfoTB(uItemIndex);
if(!pGET)
{
CHAR Buff[255];
memset(Buff,0,255);
sprintf(Buff,"找不到对应物品的表格定义，请确定CommonItem资源正确 ItemType=%d",uItemIndex);
AssertEx(pGET,Buff);
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemRulerCheck::CheckTypeRuler] GetCommItemInfoTB index is error [%d]",uItemIndex);
return FALSE;
}
return CheckRuler(ruler,pGET->m_nRulerID);
}
break;
case ICLASS_TASKITEM:
{
TASKITEM_INFO_TB* pGET = g_ItemTable.GetTaskItemInfoTB(uItemIndex);
if(!pGET)
{
CHAR Buff[255];
memset(Buff,0,255);
sprintf(Buff,"找不到对应物品的表格定义，请确定TaskItem资源正确 ItemType=%d",uItemIndex);
AssertEx(pGET,Buff);
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemRulerCheck::CheckTypeRuler] GetTaskItemInfoTB index is error [%d]",uItemIndex);
return FALSE;
}
return CheckRuler(ruler,pGET->m_nRulerID);
}
break;
case ICLASS_GEM:
{
GEMINFO_TB* pGET = g_ItemTable.GetGemInfoTB(uItemIndex);
if(!pGET)
{
CHAR Buff[255];
memset(Buff,0,255);
sprintf(Buff,"找不到对应物品的表格定义，请确定Gem资源正确 ItemType=%d",uItemIndex);
AssertEx(pGET,Buff);
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemRulerCheck::CheckTypeRuler] GetGemInfoTB index is error [%d]",uItemIndex);
return FALSE;
}
return CheckRuler(ruler,pGET->m_nRulerID);
}
break;
case ICLASS_STOREMAP:
{
STORE_MAP_INFO_TB* pGET = g_ItemTable.GetStoreMapTB(uItemIndex);
if(!pGET)
{
CHAR Buff[255];
memset(Buff,0,255);
sprintf(Buff,"找不到对应物品的表格定义，请确定藏宝图资源正确 ItemType=%d",uItemIndex);
AssertEx(pGET,Buff);
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemRulerCheck::CheckTypeRuler] GetStoreMapTB index is error [%d]",uItemIndex);
return FALSE;
}
return CheckRuler(ruler,pGET->m_nRulerID);
break;
}
case ICLASS_EXTRABAG:
{
EXTRABAG_INFO_TB* pGET = g_ItemTable.GetExtraBagInfoTB(uItemIndex);
if(!pGET)
{
CHAR Buff[255];
memset(Buff,0,255);
sprintf(Buff,"找不到对应物品的表格定义，请确定藏宝图资源正确 ItemType=%d",uItemIndex);
AssertEx(pGET,Buff);
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemRulerCheck::CheckTypeRuler] GetExtraBagInfoTB index is error [%d]",uItemIndex);
return FALSE;
}
return CheckRuler(ruler,pGET->m_nRulerID);
break;
}
case ICLASS_TALISMAN:
Assert(FALSE);
break;
case ICLASS_GUILDITEM:
Assert(FALSE);
break;
case ICLASS_SOUL_BEAD:
{
SOUL_BEAD_INFO_TB* pGET = g_ItemTable.GetSoulBeadTB(uItemIndex);
if(!pGET)
{
CHAR Buff[255];
memset(Buff,0,255);
sprintf(Buff,"找不到对应物品的表格定义，请确定装备资源正确 ItemType=%d",uItemIndex);
AssertEx(pGET,Buff);
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemRulerCheck::CheckTypeRuler] GetEquipTB index is error [%d]",uItemIndex);
return FALSE;
}
return CheckRuler(ruler,pGET->m_nRuleID);
}
break;
case ICLASS_MOUNT: // [7/8/2010 陈军龙]
{
MOUNT_INFO_TB* pGET = g_ItemTable.GetMountInfoTB(uItemIndex);
if(!pGET)
{
CHAR Buff[255];
memset(Buff,0,255);
sprintf(Buff,"找不到对应坐骑的表格定义，请确定坐骑资源正确 ItemType=%d",uItemIndex);
AssertEx(pGET,Buff);
g_pLog->FastSaveLog( LOG_FILE_1, "[ItemRulerCheck::CheckTypeRuler] GetMountInfoTB index is error [%d]",uItemIndex);
return FALSE;
}
//return CheckRuler(ruler,pGET->m_nRulerID);
return TRUE;
break;
}
default:
Assert(FALSE);
break;
}
Assert(FALSE);
return FALSE;
__LEAVE_FUNCTION
return FALSE;
}
| [
"tangming032@outlook.com"
] | tangming032@outlook.com |
1b3981ed568d0fe48715a0db9f1786b1f489918b | 1eef0e5b03d3eb7a007cd123f6b64ac154de6ed6 | /josh_blob/cv.cpp | 10c9119bd5b17db9e35dee9bb3ca8e5f2500f43e | [] | no_license | aviidlee/FollowRat | f5fe3ede735f6a9b055df87e4d9af49969de8891 | b487a46da9229197fb882f01c4b9f0790a30113c | refs/heads/master | 2021-01-10T14:01:52.449336 | 2015-09-28T22:55:18 | 2015-09-28T22:55:18 | 43,330,597 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,500 | cpp | #include <opencv2/highgui/highgui.hpp>
#include <opencv2/objdetect/objdetect.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/features2d/features2d.hpp>
//Don't need core as highgui already has core
#include <iostream>
#include <string>
using namespace std;
using namespace cv;
int main(int argc, char** argv)
{
string WINDOW_NAME = "Window";
cout << "Start" << endl;
Mat img = imread(argv[1], CV_LOAD_IMAGE_UNCHANGED);
if (img.empty())
{
cout << "Error, image empty" << endl;
//system("pause");
return -1;
}
SimpleBlobDetector::Params params;
params.minThreshold = 40;
params.maxThreshold = 60;
params.thresholdStep = 5;
params.minDistBetweenBlobs = 70.0f;
params.filterByInertia = false;
params.filterByConvexity = false;
params.filterByColor = false;
params.blobColor = 200.0f;
params.filterByCircularity = false;
//params.minCircularity = 1.0f;
//params.maxCircularity = 200.0f;
params.filterByArea = true;
params.minArea = 10.0f;
params.maxArea = 500.0f;
SimpleBlobDetector blob_detector(params);
vector<KeyPoint> keypoints;
blob_detector.detect(img, keypoints);
for (int i=0; i<keypoints.size(); i++){
KeyPoint p = keypoints[i];
cout << keypoints[i].pt.x << "," << keypoints[i].pt.y << endl;
circle( img, p.pt, p.size, Scalar(0, 0, 255), 1, 8);
}
namedWindow(WINDOW_NAME, CV_WINDOW_AUTOSIZE);
imshow(WINDOW_NAME, img);
imwrite("test.jpg", img);
waitKey(0);
destroyWindow(WINDOW_NAME);
cout << "Done";
return 0;
}
| [
"joshua.arnold1@uqconnect.edu.au"
] | joshua.arnold1@uqconnect.edu.au |
a80b1f96e9bcd482fb6521f1f5f5ee72f15e99f0 | 3ff145e1a00c9d4a926c634aec3357885e7dc0f5 | /include/networkit/scd/LocalTightnessExpansion.hpp | e1599e891a0954ede0ed7f0b400a8e0d2b7bc367 | [
"MIT"
] | permissive | Dipsingh/networkit | f9c569b30e8fa40ce677eac8d5a71add53998457 | e2ebbff66d3fc83384e9e765b767ab320202220f | refs/heads/master | 2023-06-25T13:53:11.048548 | 2021-07-17T08:33:25 | 2021-07-17T08:33:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,372 | hpp | // networkit-format
#ifndef NETWORKIT_SCD_LOCAL_TIGHTNESS_EXPANSION_HPP_
#define NETWORKIT_SCD_LOCAL_TIGHTNESS_EXPANSION_HPP_
#include <networkit/scd/SelectiveCommunityDetector.hpp>
namespace NetworKit {
/**
* The Local Tightness Expansion (LTE) algorithm.
*
* The algorithm can handle weighted graphs.
*
* This is the local community expansion algorithm described in
*
* Huang, J., Sun, H., Liu, Y., Song, Q., & Weninger, T. (2011).
* Towards Online Multiresolution Community Detection in Large-Scale Networks.
* PLOS ONE, 6(8), e23829.
* https://doi.org/10.1371/journal.pone.0023829
*/
class LocalTightnessExpansion : public SelectiveCommunityDetector {
private:
double alpha;
public:
/**
* Constructs the Local Tightness Expansion algorithm.
*
* @param[in] G The graph to detect communities on
* @param[in] alpha Tightness coefficient - smaller values lead to larger communities
*/
LocalTightnessExpansion(const Graph &g, double alpha = 1.0);
/**
* Expands a set of seed nodes into a community.
*
* @param[in] s The seed nodes
* @return A community of the seed nodes
*/
std::set<node> expandOneCommunity(const std::set<node> &s) override;
using SelectiveCommunityDetector::expandOneCommunity;
};
} // namespace NetworKit
#endif // NETWORKIT_SCD_LOCAL_TIGHTNESS_EXPANSION_HPP_
| [
"michael.hamann@kit.edu"
] | michael.hamann@kit.edu |
8e23297a609bcf4f380fa2287f618b8e88062d28 | 36cde1bc5497252034b20d090092f55a50e3d56e | /src/mafft_alignment.cpp | 8c9bd0de69838ae3fe7e1eeb214d2066516b8f37 | [] | no_license | ariloytynoja/prank-msa | 7ab41752085e90202cb3ffa01383be2ae5a6f079 | f372449bb9ef1d1081ba5759cca8493046869fb2 | refs/heads/master | 2023-08-31T16:11:49.478491 | 2023-08-24T10:24:14 | 2023-08-24T10:24:14 | 36,357,581 | 17 | 8 | null | 2022-06-09T11:21:16 | 2015-05-27T09:41:49 | C++ | UTF-8 | C++ | false | false | 4,769 | cpp | #include "mafft_alignment.h"
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include "config.h"
#include <algorithm>
#include <unistd.h>
#if defined (__APPLE__)
#include <mach-o/dyld.h>
#endif
using namespace std;
Mafft_alignment::Mafft_alignment()
{
}
bool Mafft_alignment::test_executable()
{
#if defined (__CYGWIN__)
char path[200] = "";
int length = readlink("/proc/self/exe",path,200-1);
string epath = string(path).substr(0,length);
if (epath.find("/")!=std::string::npos)
epath = epath.substr(0,epath.rfind("/")+1);
mafftpath = epath;
epath = epath+"sh.exe "+epath+"mafft -h >/dev/null 2>/dev/null";
int status = system(epath.c_str());
return WEXITSTATUS(status) == 1;
# else
char path[200] = "";
string epath;
#if defined (__APPLE__)
uint32_t size = sizeof(path);
_NSGetExecutablePath(path, &size);
epath = string(path);
if (epath.find("/")!=std::string::npos)
epath = epath.substr(0,epath.rfind("/")+1);
//epath = "DYLD_LIBRARY_PATH="+epath+" "+epath;
#else
int length = readlink("/proc/self/exe",path,200-1);
epath = string(path).substr(0,length);
if (epath.find("/")!=std::string::npos)
epath = epath.substr(0,epath.rfind("/")+1);
#endif
mafftpath = epath;
epath = epath+"mafft -h >/dev/null 2>/dev/null";
int status = system(epath.c_str());
if(WEXITSTATUS(status) == 1)
return true;
mafftpath = "";
status = system("mafft -h >/dev/null 2>/dev/null");
return WEXITSTATUS(status) == 1;
#endif
}
void Mafft_alignment::align_sequences(vector<string> *names,vector<string> *sequences)
{
ofstream m_output;
stringstream m_name;
int r = rand();
while(true)
{
m_name <<tmp_dir<<"/m"<<r<<".fas";
ifstream m_file(m_name.str().c_str());
if(!m_file)
{
m_output.open( m_name.str().c_str(), (ios::out) );
break;
}
r = rand();
}
vector<string>::iterator ni = names->begin();
vector<string>::iterator si = sequences->begin();
for(;ni!=names->end();ni++,si++)
{
m_output<<">"<<*ni<<endl<<*si<<endl;
}
m_output.close();
stringstream command;
command << mafftpath<<"mafft "<<tmp_dir<<"/m"<<r<<".fas 2> /dev/null";
if(NOISE>0)
cout<<"cmd: "<<command.str()<<endl;
// #if defined (__CYGWIN__)
// char path[200];
// int length = readlink("/proc/self/exe",path,200-1);
// string epath = string(path).substr(0,length);
// epath.replace(epath.rfind("prank"),string("prank").size(),string(""));
// command << epath<<"sh.exe "<<epath<<"mafft "<<tmp_dir<<"m"<<r<<".fas 2>/dev/null";
// # else
// command << "mafft "+tmp_dir+"m"<<r<<".fas 2>/dev/null";
// #endif
FILE *fpipe;
if ( !(fpipe = (FILE*)popen(command.str().c_str(),"r")) )
{
perror("Problems with mafft pipe.\nExiting.\n");
exit(1);
}
names->clear();
sequences->clear();
// read mafft output
string name, sequence = ""; // Initialization
char temp[256];
while ( fgets( temp, sizeof temp, fpipe))
{
string line(temp);
if (line[0] == '>')
{
line = this->remove_last_whitespaces(line);
// If a name and a sequence were found
if ((name != "") && (sequence != ""))
{
names->push_back(name);
sequence = this->remove_whitespaces(sequence);
transform( sequence.begin(), sequence.end(), sequence.begin(), (int(*)(int))toupper );
sequences->push_back(sequence);
name = "";
sequence = "";
}
name = line;
name.erase(name.begin()); // Character > deletion
}
else
{
sequence += temp; // Sequence isolation
}
}
// Addition of the last sequence in file
if ((name != "") && (sequence != ""))
{
names->push_back(name);
sequence = this->remove_whitespaces(sequence);
transform( sequence.begin(), sequence.end(), sequence.begin(), (int(*)(int))toupper );
sequences->push_back(sequence);
}
pclose(fpipe);
if(sequences->size()==0)
{
cout<<"\nError: Initial alignment with Mafft failed. The output generated was:\n";
command.str("");
command << mafftpath<<"mafft "<<tmp_dir<<"/m"<<r<<".fas 2>&1";
int i = system(command.str().c_str());
cout<<"\nNow exiting.\n";
exit(0);
}
//remove file
if( remove( m_name.str().c_str() ) != 0)
perror("Error deleting temporary file in Mafft_alignment::align_sequences");
}
| [
"ari.loytynoja@gmail.com"
] | ari.loytynoja@gmail.com |
8bc829d0316157f539353c92763e1cd11614c210 | 4a41a7e44e4462121c67145a736734f8f1fa7358 | /geometry/src/Momentum4D.cpp | bb93f279e811077dce3e4bfe60af2188662d8171 | [] | no_license | tigerInAJar/typeCase | 965bba23f3aa0c2434cd44bc6f83b12dd640b490 | 067d3dab23c40658c80de2701f452d2fc55edec3 | refs/heads/master | 2020-04-13T02:55:05.085444 | 2019-08-15T18:43:09 | 2019-08-15T18:43:09 | 162,915,782 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,666 | cpp | #include "geometry.h"
#ifdef USEROOT
#include <TObject.h>
#endif
// momentum4D::momentum4D(): vector4D()
// {
// Undefined();
// }
momentum4D::momentum4D(const point4D& p) : vector4D(p)
{
mass = sqrt(abs(W() * W() - X() * X() - Y() * Y() - Z() * Z()));
velocity = vector3D(X() / W(), Y() / W(), Z() / W());
gamma = 1 / sqrt(1 - velocity.R() * velocity.R());
}
momentum4D::momentum4D(const vector4D& vec) : vector4D(vec)
{
mass = sqrt(abs(W() * W() - X() * X() - Y() * Y() - Z() * Z()));
velocity = vector3D(X() / W(), Y() / W(), Z() / W());
gamma = 1 / sqrt(1 - velocity.R() * velocity.R());
}
#ifdef USEROOT
momentum4D::momentum4D(const momentum4D& m) : vector4D()
#else
momentum4D::momentum4D(const momentum4D& m) : vector4D()
#endif
{
setVE(m.Velocity(), m.Energy());
}
momentum4D::momentum4D(const point3D& p, double energy) : vector4D(p.X(), p.Y(), p.Z(), energy)
{
mass = sqrt(abs(energy * energy - p.R() * p.R()));
velocity = vector3D(p) * (1 / energy);
gamma = 1 / sqrt(1 - velocity.R() * velocity.R());
}
momentum4D::momentum4D(double x, double y, double z, double e) : vector4D(x, y, z, e)
{
mass = sqrt(abs(e * e - x * x - y * y - z * z));
velocity = vector3D(x, y, z) * (1 / e);
gamma = 1 / sqrt(1 - velocity.R() * velocity.R());
}
void momentum4D::setPM(const vector3D& p, double m)
{
mass = m;
point4D::setValues(p.X(), p.Y(), p.Z(), sqrt(p.R() * p.R() + m * m));
velocity = p * (1 / point4D::value4);
gamma = 1 / sqrt(1 - velocity.R() * velocity.R());
}
void momentum4D::setVM(const vector3D& v, double m)
{
mass = m;
velocity = v;
gamma = 1 / sqrt(1 - velocity.R() * velocity.R());
double e = m / sqrt(1 - v.R() * v.R());
point4D::setValues(e * v.X(), e * v.Y(), e * v.Z(), e);
}
void momentum4D::setVE(const vector3D& vec, double e)
{
velocity = vec;
gamma = 1 / sqrt(1 - velocity.R() * velocity.R());
mass = e / gamma; // sqrt(abs(1-vec.R()*vec.R()-Y()*Y()-Z()*Z()))*e;
point4D::setValues(e * vec.X(), e * vec.Y(), e * vec.Z(), e);
}
// void momentum4D::setPE(const vector3D &p, double e)
// {
// mass=sqrt(abs(e*e-p.R()*p.R()));
// velocity=p*(1/e);
// gamma=1/sqrt(1-velocity.R()*velocity.R());
// point4D::setValues(p.X(), p.Y(), p.Z(), e);
// }
// double momentum4D::Energy() const
// {
// return point4D::value4;
// }
// double momentum4D::Mass() const
// {
// return mass;
// }
// double momentum4D::Beta() const
// {
// return velocity.R();
// }
// double momentum4D::Gamma() const
// {
// return gamma;
// }
// vector3D momentum4D::Velocity() const
// {
// return velocity;
// }
// vector3D momentum4D::Momentum()const
// {
// return vector3D(point4D::value1,point4D::value2,point4D::value3);
// }
// vector3D momentum4D::Direction()const
// {
// vector3D ret(point4D::value1,point4D::value2,point4D::value3);
// ret.normalize();
// return ret;
// }
momentum4D momentum4D::boost(const vector3D& be) const
{
momentum4D ret;
vector3D mom = Momentum();
float gam = 1 / sqrt(1 - be * be);
ret.setPE(mom + be * ((gam - 1) / (be * be) * (be * mom)) + be * gam * W(),
gam * (W() + be * mom));
return ret;
}
momentum4D momentum4D::CM(const momentum4D& v1, const momentum4D& v2, const momentum4D& v3,
const momentum4D& v4, const momentum4D& v5)
{
vector3D u[5];
double g[5], m[5];
int n = 0;
if (v1.getState() == _regular_) {
u[n] = v1.Velocity();
m[n] = v1.Mass();
g[n] = 1 / sqrt(1 - u[n] * u[n]);
n++;
}
if (v2.getState() == _regular_) {
u[n] = v2.Velocity();
m[n] = v2.Mass();
g[n] = 1 / sqrt(1 - u[n] * u[n]);
n++;
}
if (v3.getState() == _regular_) {
u[n] = v3.Velocity();
m[n] = v3.Mass();
g[n] = 1 / sqrt(1 - u[n] * u[n]);
n++;
}
if (v4.getState() == _regular_) {
u[n] = v4.Velocity();
m[n] = v4.Mass();
g[n] = 1 / sqrt(1 - u[n] * u[n]);
n++;
}
if (v5.getState() == _regular_) {
u[n] = v5.Velocity();
m[n] = v5.Mass();
g[n] = 1 / sqrt(1 - u[n] * u[n]);
n++;
}
vector3D U(0, 0, 0);
double mas = 0;
double M = 0;
for (int i = 0; i < n; i++) {
U = U + (u[i] * m[i] * g[i]);
mas += m[i] * g[i];
M += m[i] * m[i];
for (int j = 0; j < n; j++)
if (i != j)
M += m[i] * m[j] * g[i] * g[j] * (1 - u[i] * u[j]);
}
U = U * (1 / mas);
M = sqrt(abs(M));
momentum4D ret;
ret.setVM(U, M);
return ret;
}
//#ifdef USEQT
string momentum4D::toString(int pt) const
{
if (getState() != _regular_ && getState() != _zero_)
return point4D::toString();
int ptt = pt & 3;
pt = pt - ptt;
point3D p = Momentum();
double q = Energy();
string pp = "p", qq = "e";
switch (pt) {
case -1:
case 0:
p = Momentum();
q = Energy();
pp = "p";
qq = "e";
break;
case 4:
p = Momentum();
q = Mass();
pp = "p";
qq = "m";
break;
case 8:
p = Velocity();
q = Energy();
pp = "v";
qq = "e";
break;
case 12:
p = Velocity();
q = Mass();
pp = "v";
qq = "m";
break;
}
return (string("(") + pp + " = " + p.toString(ptt) + ", " + qq + " = " + string_number(q) + ")");
}
//#endif
ostream& operator<<(ostream& o, const momentum4D& m)
{
vector3D tmp(m.Momentum());
o << "(p = " << tmp;
o << ", e = " << m.Energy() << ")";
return o;
}
// void momentum4D::operator =(const momentum4D &vec)
// {
// setPE(vector3D(vec[0],vec[1],vec[2]),vec[3]);
// }
// int momentum4D::operator == (const momentum4D &m)const
// {
// return ((Velocity()==m.Velocity())&&(Energy()==m.Energy()));
// }
// momentum4D momentum4D::operator! ()const
// {
// momentum4D m(*this);
// m.transpose();
// return m;
// }
// momentum4D momentum4D::operator+(const momentum4D &vec) const
// {
// return momentum4D(Momentum()+vec.Momentum(),vec.Energy()+Energy());
// }
// momentum4D momentum4D::operator-(const momentum4D &vec) const
// {
// return momentum4D(Momentum()-vec.Momentum(),Energy()-vec.Energy());
// }
// double momentum4D::operator*(const momentum4D &vec) const
// {
// return (vec.Energy()*point4D::value4-Momentum()*vec.Momentum());
// }
// momentum4D momentum4D::operator*(double factor)const
// {
// return momentum4D(Momentum()*factor,point4D::value4*factor);
// }
momentum4D operator*(double factor, const momentum4D& vec)
{
return momentum4D(vec.Momentum() * factor, vec.Energy() * factor);
}
// double momentum4D::operator[](int pos)const
// {
// return vector4D::operator[](pos);
// }
// double momentum4D::Rapidity()const
// {
// return
// 0.5*(log((point4D::value4+point4D::value3)/(point4D::value4-point4D::value3)));
// }
double momentum4D::Rapidity(const vector3D& axis) const
{
double t_pt = pt(axis);
return 0.5 * (log((point4D::value4 + t_pt) / (point4D::value4 - t_pt)));
}
// double momentum4D::px()const
// {
// return point4D::value1;
// }
// double momentum4D::py()const
// {
// return point4D::value2;
// }
// double momentum4D::pz()const
// {
// return point4D::value3;
// }
// double momentum4D::e()const
// {
// return point4D::value4;
// }
// double momentum4D::Px()const
// {
// return point4D::value1;
// }
// double momentum4D::Py()const
// {
// return point4D::value2;
// }
// double momentum4D::Pz()const
// {
// return point4D::value3;
// }
// double momentum4D::E()const
// {
// return point4D::value4;
// }
// double momentum4D::Pt()const
// {
// return point4D::value3;
// }
// double momentum4D::Pt(const vector3D &axis)const
// {
// return (Momentum()-axis*(Momentum()*axis)/(axis.R()*axis.R())).R();
// }
// vector3D momentum4D::Pt_v(const vector3D &axis)const
// {
// return Momentum()-axis*(Momentum()*axis)/(axis.R()*axis.R());
// }
// double momentum4D::Pl()const
// {
// return f_rho;
// }
// double momentum4D::Pl(const vector3D &axis)const
// {
// return (axis*(Momentum()*axis)/(axis.R()*axis.R())).R();
// }
// vector3D momentum4D::Pl_v(const vector3D &axis)const
// {
// return axis*(Momentum()*axis)/(axis.R()*axis.R());
// }
// double momentum4D::pt()const
// {
// return point4D::value3;
// }
// double momentum4D::pt(const vector3D &axis)const
// {
// return (Momentum()-axis*(Momentum()*axis)/(axis.R()*axis.R())).R();
// }
// vector3D momentum4D::pt_v(const vector3D &axis)const
// {
// return Momentum()-axis*(Momentum()*axis)/(axis.R()*axis.R());
// }
// double momentum4D::pl()const
// {
// return f_rho;
// }
// double momentum4D::pl(const vector3D &axis)const
// {
// return (axis*(Momentum()*axis)/(axis.R()*axis.R())).R();
// }
// vector3D momentum4D::pl_v(const vector3D &axis)const
// {
// return axis*(Momentum()*axis)/(axis.R()*axis.R());
// }
| [
"2w2922wiu9g1@opayq.com"
] | 2w2922wiu9g1@opayq.com |
0c0c20e3583c6df1762640fec59ca45f752ce06b | def1624c52b9ca2ba9e35c5c3326e1d537263e9e | /thread.h | ff90f0db2bf2fa1c9b9d4f7ba87bce69eee0dfd2 | [] | no_license | magik6k/CCE | 63c9c5a80d5c4e4d34459b7f3938e6983b8f16c7 | e6a3558039ce0cb5dcfec788fda51c5d0dd89d6f | refs/heads/master | 2021-01-21T02:30:46.817956 | 2014-01-15T21:33:44 | 2014-01-15T21:33:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 507 | h | #pragma once
#include <pthread.h>
#define thread_default_heap (512*1024)
class thread
{
private:
void* data;
void *(*fn) (void *);
pthread_t thr;
void init(void *(*func) (void *), void* dp, unsigned int heapsz);
public:
thread(void *(*func) (void *));
thread(void *(*func) (void *), void* dp);
thread(void *(*func) (void *), unsigned int heapsz);
thread(void *(*func) (void *), void* dp, unsigned int heapsz);
~thread();
};
| [
"magik6000@o2.pl"
] | magik6000@o2.pl |
32af36ec8df82528d1ea2058b397044e8f81a6fb | 21fc7a4db2517d592db01dcfd2d1822417688d13 | /DoublyLinkedList/DoublyLinkedList.h | ae291b968e32d1e8af30022db4f6ae864497b74b | [] | no_license | jsmalls128/Assignment2 | 42979295746f8b05ea5920d7ff3094364471b9a7 | 698c6f7b0cb433a8884bb1076f9da1b52624ad59 | refs/heads/master | 2020-03-06T16:53:27.754678 | 2018-03-27T12:12:21 | 2018-03-27T12:12:21 | 126,980,904 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 865 | h | #include "ItemType.h"
struct NodeType{
ItemType data;
NodeType* next;
NodeType* back;
};
class DoublyLinkedList{
int length;
NodeType *head; // Points to start of list or NULL
NodeType *current; // Points to the current pointer
public:
DoublyLinkedList(); // Creates a DoublyLinkedList
~DoublyLinkedList(); // Frees all nodes in a DoublyLinkedList
int lengthIs() const; // returns length of the list
void insertItem(ItemType &item); // inserts an item in a sorted manner
void deleteItem(ItemType &item); // deletes the node that contains the item
void print(); // prints the contents of the list
void additivePairs(ItemType &item); // finds the amount and additive pairs of the item
}; | [
"jmb82096@uga.edu"
] | jmb82096@uga.edu |
595811d5067377a0a645bc19c937eccea8685e18 | 83bacfbdb7ad17cbc2fc897b3460de1a6726a3b1 | /third_party/skia/src/ports/SkFontMgr_fontconfig_factory.cpp | b959acbbe2c2f064c7e4f54b218c69c8d32a9935 | [
"BSD-3-Clause",
"Apache-2.0"
] | permissive | cool2528/miniblink49 | d909e39012f2c5d8ab658dc2a8b314ad0050d8ea | 7f646289d8074f098cf1244adc87b95e34ab87a8 | refs/heads/master | 2020-06-05T03:18:43.211372 | 2019-06-01T08:57:37 | 2019-06-01T08:59:56 | 192,294,645 | 2 | 0 | Apache-2.0 | 2019-06-17T07:16:28 | 2019-06-17T07:16:27 | null | UTF-8 | C++ | false | false | 282 | cpp | /*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkFontMgr.h"
#include "SkFontMgr_fontconfig.h"
SkFontMgr* SkFontMgr::Factory() {
return SkFontMgr_New_FontConfig(NULL);
}
| [
"22249030@qq.com"
] | 22249030@qq.com |
813c6777371ca46a58b7f49f49327f8aa6b91288 | 6e57bdc0a6cd18f9f546559875256c4570256c45 | /external/pdfium/core/fpdfapi/parser/fpdf_parser_decode.cpp | d7114b66c518aa6576d47ad7f1cd0117b6ab7869 | [
"BSD-3-Clause"
] | permissive | dongdong331/test | 969d6e945f7f21a5819cd1d5f536d12c552e825c | 2ba7bcea4f9d9715cbb1c4e69271f7b185a0786e | refs/heads/master | 2023-03-07T06:56:55.210503 | 2020-12-07T04:15:33 | 2020-12-07T04:15:33 | 134,398,935 | 2 | 1 | null | 2022-11-21T07:53:41 | 2018-05-22T10:26:42 | null | UTF-8 | C++ | false | false | 18,391 | cpp | // Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#include "core/fpdfapi/parser/fpdf_parser_decode.h"
#include <limits.h>
#include <algorithm>
#include <sstream>
#include <utility>
#include <vector>
#include "core/fpdfapi/cpdf_modulemgr.h"
#include "core/fpdfapi/parser/cpdf_array.h"
#include "core/fpdfapi/parser/cpdf_dictionary.h"
#include "core/fpdfapi/parser/fpdf_parser_utility.h"
#include "core/fxcodec/codec/ccodec_faxmodule.h"
#include "core/fxcodec/codec/ccodec_flatemodule.h"
#include "core/fxcodec/codec/ccodec_scanlinedecoder.h"
#include "core/fxcodec/fx_codec.h"
#include "core/fxcrt/fx_extension.h"
#include "third_party/base/numerics/safe_math.h"
namespace {
const uint32_t kMaxStreamSize = 20 * 1024 * 1024;
uint16_t GetUnicodeFromBytes(const uint8_t* bytes, bool bBE) {
return bBE ? (bytes[0] << 8 | bytes[1]) : (bytes[1] << 8 | bytes[0]);
}
bool CheckFlateDecodeParams(int Colors, int BitsPerComponent, int Columns) {
if (Colors < 0 || BitsPerComponent < 0 || Columns < 0)
return false;
pdfium::base::CheckedNumeric<int> check = Columns;
check *= Colors;
check *= BitsPerComponent;
if (!check.IsValid())
return false;
return check.ValueOrDie() <= INT_MAX - 7;
}
} // namespace
const uint16_t PDFDocEncoding[256] = {
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 0x0010, 0x0011,
0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x02d8, 0x02c7, 0x02c6,
0x02d9, 0x02dd, 0x02db, 0x02da, 0x02dc, 0x0020, 0x0021, 0x0022, 0x0023,
0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c,
0x002d, 0x002e, 0x002f, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035,
0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e,
0x003f, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 0x0050,
0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059,
0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 0x0060, 0x0061, 0x0062,
0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b,
0x006c, 0x006d, 0x006e, 0x006f, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074,
0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d,
0x007e, 0x0000, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x0192,
0x2044, 0x2039, 0x203a, 0x2212, 0x2030, 0x201e, 0x201c, 0x201d, 0x2018,
0x2019, 0x201a, 0x2122, 0xfb01, 0xfb02, 0x0141, 0x0152, 0x0160, 0x0178,
0x017d, 0x0131, 0x0142, 0x0153, 0x0161, 0x017e, 0x0000, 0x20ac, 0x00a1,
0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00aa,
0x00ab, 0x00ac, 0x0000, 0x00ae, 0x00af, 0x00b0, 0x00b1, 0x00b2, 0x00b3,
0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc,
0x00bd, 0x00be, 0x00bf, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5,
0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
0x00cf, 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 0x00e0,
0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9,
0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 0x00f0, 0x00f1, 0x00f2,
0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb,
0x00fc, 0x00fd, 0x00fe, 0x00ff};
uint32_t A85Decode(const uint8_t* src_buf,
uint32_t src_size,
uint8_t** dest_buf,
uint32_t* dest_size) {
*dest_size = 0;
*dest_buf = nullptr;
if (src_size == 0)
return 0;
// Count legal characters and zeros.
uint32_t zcount = 0;
uint32_t pos = 0;
while (pos < src_size) {
uint8_t ch = src_buf[pos];
if (ch == 'z') {
zcount++;
} else if ((ch < '!' || ch > 'u') && !PDFCharIsLineEnding(ch) &&
ch != ' ' && ch != '\t') {
break;
}
pos++;
}
// No content to decode.
if (pos == 0)
return 0;
// Count the space needed to contain non-zero characters. The encoding ratio
// of Ascii85 is 4:5.
uint32_t space_for_non_zeroes = (pos - zcount) / 5 * 4 + 4;
if (zcount > (UINT_MAX - space_for_non_zeroes) / 4)
return FX_INVALID_OFFSET;
*dest_buf = FX_Alloc(uint8_t, zcount * 4 + space_for_non_zeroes);
size_t state = 0;
uint32_t res = 0;
pos = 0;
while (pos < src_size) {
uint8_t ch = src_buf[pos++];
if (PDFCharIsLineEnding(ch) || ch == ' ' || ch == '\t')
continue;
if (ch == 'z') {
memset(*dest_buf + *dest_size, 0, 4);
state = 0;
res = 0;
*dest_size += 4;
continue;
}
// Check for the end or illegal character.
if (ch < '!' || ch > 'u')
break;
res = res * 85 + ch - 33;
if (state < 4) {
++state;
continue;
}
for (size_t i = 0; i < 4; ++i) {
(*dest_buf)[(*dest_size)++] = static_cast<uint8_t>(res >> (3 - i) * 8);
}
state = 0;
res = 0;
}
// Handle partial group.
if (state) {
for (size_t i = state; i < 5; ++i)
res = res * 85 + 84;
for (size_t i = 0; i < state - 1; ++i)
(*dest_buf)[(*dest_size)++] = static_cast<uint8_t>(res >> (3 - i) * 8);
}
if (pos < src_size && src_buf[pos] == '>')
++pos;
return pos;
}
uint32_t HexDecode(const uint8_t* src_buf,
uint32_t src_size,
uint8_t** dest_buf,
uint32_t* dest_size) {
*dest_size = 0;
if (src_size == 0) {
*dest_buf = nullptr;
return 0;
}
uint32_t i = 0;
// Find the end of data.
while (i < src_size && src_buf[i] != '>')
++i;
*dest_buf = FX_Alloc(uint8_t, i / 2 + 1);
bool bFirst = true;
for (i = 0; i < src_size; ++i) {
uint8_t ch = src_buf[i];
if (PDFCharIsLineEnding(ch) || ch == ' ' || ch == '\t')
continue;
if (ch == '>') {
++i;
break;
}
if (!std::isxdigit(ch))
continue;
int digit = FXSYS_HexCharToInt(ch);
if (bFirst)
(*dest_buf)[*dest_size] = digit * 16;
else
(*dest_buf)[(*dest_size)++] += digit;
bFirst = !bFirst;
}
if (!bFirst)
++(*dest_size);
return i;
}
uint32_t RunLengthDecode(const uint8_t* src_buf,
uint32_t src_size,
uint8_t** dest_buf,
uint32_t* dest_size) {
uint32_t i = 0;
*dest_size = 0;
while (i < src_size) {
if (src_buf[i] == 128)
break;
uint32_t old = *dest_size;
if (src_buf[i] < 128) {
*dest_size += src_buf[i] + 1;
if (*dest_size < old)
return FX_INVALID_OFFSET;
i += src_buf[i] + 2;
} else {
*dest_size += 257 - src_buf[i];
if (*dest_size < old)
return FX_INVALID_OFFSET;
i += 2;
}
}
if (*dest_size >= kMaxStreamSize)
return FX_INVALID_OFFSET;
*dest_buf = FX_Alloc(uint8_t, *dest_size);
i = 0;
int dest_count = 0;
while (i < src_size) {
if (src_buf[i] == 128)
break;
if (src_buf[i] < 128) {
uint32_t copy_len = src_buf[i] + 1;
uint32_t buf_left = src_size - i - 1;
if (buf_left < copy_len) {
uint32_t delta = copy_len - buf_left;
copy_len = buf_left;
memset(*dest_buf + dest_count + copy_len, '\0', delta);
}
memcpy(*dest_buf + dest_count, src_buf + i + 1, copy_len);
dest_count += src_buf[i] + 1;
i += src_buf[i] + 2;
} else {
int fill = 0;
if (i < src_size - 1)
fill = src_buf[i + 1];
memset(*dest_buf + dest_count, fill, 257 - src_buf[i]);
dest_count += 257 - src_buf[i];
i += 2;
}
}
return std::min(i + 1, src_size);
}
std::unique_ptr<CCodec_ScanlineDecoder> FPDFAPI_CreateFaxDecoder(
const uint8_t* src_buf,
uint32_t src_size,
int width,
int height,
const CPDF_Dictionary* pParams) {
int K = 0;
bool EndOfLine = false;
bool ByteAlign = false;
bool BlackIs1 = false;
int Columns = 1728;
int Rows = 0;
if (pParams) {
K = pParams->GetIntegerFor("K");
EndOfLine = !!pParams->GetIntegerFor("EndOfLine");
ByteAlign = !!pParams->GetIntegerFor("EncodedByteAlign");
BlackIs1 = !!pParams->GetIntegerFor("BlackIs1");
Columns = pParams->GetIntegerFor("Columns", 1728);
Rows = pParams->GetIntegerFor("Rows");
if (Rows > USHRT_MAX)
Rows = 0;
}
return CPDF_ModuleMgr::Get()->GetFaxModule()->CreateDecoder(
src_buf, src_size, width, height, K, EndOfLine, ByteAlign, BlackIs1,
Columns, Rows);
}
std::unique_ptr<CCodec_ScanlineDecoder> FPDFAPI_CreateFlateDecoder(
const uint8_t* src_buf,
uint32_t src_size,
int width,
int height,
int nComps,
int bpc,
const CPDF_Dictionary* pParams) {
int predictor = 0;
int Colors = 0;
int BitsPerComponent = 0;
int Columns = 0;
if (pParams) {
predictor = pParams->GetIntegerFor("Predictor");
Colors = pParams->GetIntegerFor("Colors", 1);
BitsPerComponent = pParams->GetIntegerFor("BitsPerComponent", 8);
Columns = pParams->GetIntegerFor("Columns", 1);
if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns))
return nullptr;
}
return CPDF_ModuleMgr::Get()->GetFlateModule()->CreateDecoder(
src_buf, src_size, width, height, nComps, bpc, predictor, Colors,
BitsPerComponent, Columns);
}
uint32_t FPDFAPI_FlateOrLZWDecode(bool bLZW,
const uint8_t* src_buf,
uint32_t src_size,
CPDF_Dictionary* pParams,
uint32_t estimated_size,
uint8_t** dest_buf,
uint32_t* dest_size) {
int predictor = 0;
int Colors = 0;
int BitsPerComponent = 0;
int Columns = 0;
bool bEarlyChange = true;
if (pParams) {
predictor = pParams->GetIntegerFor("Predictor");
bEarlyChange = !!pParams->GetIntegerFor("EarlyChange", 1);
Colors = pParams->GetIntegerFor("Colors", 1);
BitsPerComponent = pParams->GetIntegerFor("BitsPerComponent", 8);
Columns = pParams->GetIntegerFor("Columns", 1);
if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns))
return FX_INVALID_OFFSET;
}
return CPDF_ModuleMgr::Get()->GetFlateModule()->FlateOrLZWDecode(
bLZW, src_buf, src_size, bEarlyChange, predictor, Colors,
BitsPerComponent, Columns, estimated_size, dest_buf, dest_size);
}
bool PDF_DataDecode(const uint8_t* src_buf,
uint32_t src_size,
const CPDF_Dictionary* pDict,
uint32_t last_estimated_size,
bool bImageAcc,
uint8_t** dest_buf,
uint32_t* dest_size,
ByteString* ImageEncoding,
CPDF_Dictionary** pImageParms) {
CPDF_Object* pDecoder = pDict ? pDict->GetDirectObjectFor("Filter") : nullptr;
if (!pDecoder || (!pDecoder->IsArray() && !pDecoder->IsName()))
return false;
CPDF_Object* pParams =
pDict ? pDict->GetDirectObjectFor("DecodeParms") : nullptr;
std::vector<std::pair<ByteString, CPDF_Object*>> DecoderArray;
if (CPDF_Array* pDecoders = pDecoder->AsArray()) {
CPDF_Array* pParamsArray = ToArray(pParams);
for (size_t i = 0; i < pDecoders->GetCount(); ++i) {
DecoderArray.push_back(
{pDecoders->GetStringAt(i),
pParamsArray ? pParamsArray->GetDictAt(i) : nullptr});
}
} else {
DecoderArray.push_back(
{pDecoder->GetString(), pParams ? pParams->GetDict() : nullptr});
}
uint8_t* last_buf = const_cast<uint8_t*>(src_buf);
uint32_t last_size = src_size;
size_t nSize = DecoderArray.size();
for (size_t i = 0; i < nSize; ++i) {
int estimated_size = i == nSize - 1 ? last_estimated_size : 0;
ByteString decoder = DecoderArray[i].first;
CPDF_Dictionary* pParam = ToDictionary(DecoderArray[i].second);
uint8_t* new_buf = nullptr;
uint32_t new_size = 0xFFFFFFFF;
uint32_t offset = FX_INVALID_OFFSET;
if (decoder == "Crypt")
continue;
if (decoder == "FlateDecode" || decoder == "Fl") {
if (bImageAcc && i == nSize - 1) {
*ImageEncoding = "FlateDecode";
*dest_buf = last_buf;
*dest_size = last_size;
*pImageParms = pParam;
return true;
}
offset = FPDFAPI_FlateOrLZWDecode(false, last_buf, last_size, pParam,
estimated_size, &new_buf, &new_size);
} else if (decoder == "LZWDecode" || decoder == "LZW") {
offset = FPDFAPI_FlateOrLZWDecode(true, last_buf, last_size, pParam,
estimated_size, &new_buf, &new_size);
} else if (decoder == "ASCII85Decode" || decoder == "A85") {
offset = A85Decode(last_buf, last_size, &new_buf, &new_size);
} else if (decoder == "ASCIIHexDecode" || decoder == "AHx") {
offset = HexDecode(last_buf, last_size, &new_buf, &new_size);
} else if (decoder == "RunLengthDecode" || decoder == "RL") {
if (bImageAcc && i == nSize - 1) {
*ImageEncoding = "RunLengthDecode";
*dest_buf = last_buf;
*dest_size = last_size;
*pImageParms = pParam;
return true;
}
offset = RunLengthDecode(last_buf, last_size, &new_buf, &new_size);
} else {
// If we get here, assume it's an image decoder.
if (decoder == "DCT")
decoder = "DCTDecode";
else if (decoder == "CCF")
decoder = "CCITTFaxDecode";
*ImageEncoding = decoder;
*pImageParms = pParam;
*dest_buf = last_buf;
*dest_size = last_size;
return true;
}
if (last_buf != src_buf)
FX_Free(last_buf);
if (offset == FX_INVALID_OFFSET) {
FX_Free(new_buf);
return false;
}
last_buf = new_buf;
last_size = new_size;
}
ImageEncoding->clear();
*pImageParms = nullptr;
*dest_buf = last_buf;
*dest_size = last_size;
return true;
}
WideString PDF_DecodeText(const uint8_t* src_data, uint32_t src_len) {
WideString result;
if (src_len >= 2 && ((src_data[0] == 0xfe && src_data[1] == 0xff) ||
(src_data[0] == 0xff && src_data[1] == 0xfe))) {
uint32_t max_chars = (src_len - 2) / 2;
if (!max_chars)
return result;
bool bBE = src_data[0] == 0xfe || (src_data[0] == 0xff && !src_data[2]);
wchar_t* dest_buf = result.GetBuffer(max_chars);
const uint8_t* uni_str = src_data + 2;
int dest_pos = 0;
for (uint32_t i = 0; i < max_chars * 2; i += 2) {
uint16_t unicode = GetUnicodeFromBytes(uni_str + i, bBE);
if (unicode != 0x1b) {
dest_buf[dest_pos++] = unicode;
continue;
}
i += 2;
while (i < max_chars * 2) {
uint16_t unicode2 = GetUnicodeFromBytes(uni_str + i, bBE);
i += 2;
if (unicode2 == 0x1b)
break;
}
}
result.ReleaseBuffer(dest_pos);
} else {
wchar_t* dest_buf = result.GetBuffer(src_len);
for (uint32_t i = 0; i < src_len; ++i)
dest_buf[i] = PDFDocEncoding[src_data[i]];
result.ReleaseBuffer(src_len);
}
return result;
}
WideString PDF_DecodeText(const ByteString& bstr) {
return PDF_DecodeText(reinterpret_cast<const uint8_t*>(bstr.c_str()),
bstr.GetLength());
}
ByteString PDF_EncodeText(const wchar_t* pString, int len) {
if (len == -1)
len = wcslen(pString);
ByteString result;
char* dest_buf1 = result.GetBuffer(len);
int i;
for (i = 0; i < len; ++i) {
int code;
for (code = 0; code < 256; ++code) {
if (PDFDocEncoding[code] == pString[i])
break;
}
if (code == 256)
break;
dest_buf1[i] = code;
}
result.ReleaseBuffer(i);
if (i == len)
return result;
if (len > INT_MAX / 2 - 1) {
result.ReleaseBuffer(0);
return result;
}
int encLen = len * 2 + 2;
uint8_t* dest_buf2 = reinterpret_cast<uint8_t*>(result.GetBuffer(encLen));
dest_buf2[0] = 0xfe;
dest_buf2[1] = 0xff;
dest_buf2 += 2;
for (int j = 0; j < len; ++j) {
*dest_buf2++ = pString[j] >> 8;
*dest_buf2++ = static_cast<uint8_t>(pString[j]);
}
result.ReleaseBuffer(encLen);
return result;
}
ByteString PDF_EncodeText(const WideString& str) {
return PDF_EncodeText(str.c_str(), str.GetLength());
}
ByteString PDF_EncodeString(const ByteString& src, bool bHex) {
std::ostringstream result;
int srclen = src.GetLength();
if (bHex) {
result << '<';
for (int i = 0; i < srclen; ++i) {
char buf[2];
FXSYS_IntToTwoHexChars(src[i], buf);
result << buf[0];
result << buf[1];
}
result << '>';
return ByteString(result);
}
result << '(';
for (int i = 0; i < srclen; ++i) {
uint8_t ch = src[i];
if (ch == 0x0a) {
result << "\\n";
continue;
}
if (ch == 0x0d) {
result << "\\r";
continue;
}
if (ch == ')' || ch == '\\' || ch == '(')
result << '\\';
result << static_cast<char>(ch);
}
result << ')';
return ByteString(result);
}
bool FlateEncode(const uint8_t* src_buf,
uint32_t src_size,
uint8_t** dest_buf,
uint32_t* dest_size) {
CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
return pEncoders->GetFlateModule()->Encode(src_buf, src_size, dest_buf,
dest_size);
}
bool PngEncode(const uint8_t* src_buf,
uint32_t src_size,
uint8_t** dest_buf,
uint32_t* dest_size) {
CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
return pEncoders->GetFlateModule()->PngEncode(src_buf, src_size, dest_buf,
dest_size);
}
uint32_t FlateDecode(const uint8_t* src_buf,
uint32_t src_size,
uint8_t** dest_buf,
uint32_t* dest_size) {
CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
return pEncoders->GetFlateModule()->FlateOrLZWDecode(
false, src_buf, src_size, false, 0, 0, 0, 0, 0, dest_buf, dest_size);
}
| [
"dongdong331@163.com"
] | dongdong331@163.com |
1f7fde8bbf8048cc346f8c34060a6fea4adeca92 | a9073f20deffa22b5eaba6916cf67fddb6412482 | /cppexp/filework/main2.cpp | a816298cb897555c6c63db441d737dc1090d0a52 | [] | no_license | zhaowei11594/scripts | 6e680afcb2fe41e544104af3957bf248c080d5da | 70a5edd4c50f780b89ba2238caae79999a406429 | refs/heads/master | 2021-01-20T13:43:03.022966 | 2017-05-07T07:46:39 | 2017-05-07T07:46:39 | 90,516,713 | 0 | 0 | null | 2017-05-07T07:41:53 | 2017-05-07T07:41:53 | null | UTF-8 | C++ | false | false | 280 | cpp | #include<iostream>
#include<stdio.h>
#include<fstream>
int f(int x)
{
static int y = 0;
y++;
return x + y;
}
int main(int argc, char** argv)
{
printf("Start...\n");
for(int i = 0; i < 10; i++)
{
printf("%d: %d\n", i, f(1));
}
return 0;
}
| [
"ra22341@ya.ru"
] | ra22341@ya.ru |
b8552bb5c30fd1ac908883ca7baeb538f8128c80 | dbb4c490acf0727dfc431ed09130259af23e04a6 | /CP/Assignment1-STL/Yogesh/pair.cpp | 732c85c90231d9922e41bd4234f0a03201660961 | [] | no_license | varshavasthavi/SummerProjects18 | 0ef0d3b722e384efab25e435a198d6594cfe33a2 | 6219c20e2c7ed031bc8064c01c565c7bbd2228f6 | refs/heads/master | 2020-03-15T12:58:07.626144 | 2018-06-23T16:22:32 | 2018-06-23T16:22:32 | 132,155,712 | 2 | 0 | null | 2018-05-04T15:10:54 | 2018-05-04T15:10:53 | null | UTF-8 | C++ | false | false | 1,186 | cpp | #include<bits/stdc++.h>
using namespace std;
bool comp1(pair<int,int> p1, pair<int,int> p2)
{
if(p1.first<p2.first)
return 1;
else if(p1.first==p2.first)
{
if(p1.second<p2.second)
return 1;
return 0;
}
return 0;
}
bool comp2(pair<int,int> p1, pair<int,int> p2)
{
if(p1.second<p2.second)
return 1;
else if(p1.second==p2.second)
{
if(p1.first<p2.first)
return 1;
return 0;
}
return 0;
}
int main()
{
vector< pair<int,int> >v(5, make_pair(0,0));
int Q;
cin>>Q;
while(Q--)
{
int choice,x,y,z;
cin>>choice;
if(choice==1)
{
cin>>x>>y>>z;
v[x-1].first=y;
v[x-1].second=z;
}
else if(choice==2)
{
int choice2;
cin>>choice2;
if(choice2==1)
sort(v.begin(),v.end(),comp1);
else
sort(v.begin(),v.end(),comp2);
}
else
{
for(int i=0;i<5;i++)
cout<<'('<<v[i].first<<" "<<v[i].second<<')';
cout<<endl;
}
}
return 0;
}
| [
"yogeshchoubey7@gmail.com"
] | yogeshchoubey7@gmail.com |
23805b659d5db856cb6c215dba1e784385a08c14 | 345cdcd53f74bb7c4371cf67e4f1b3f0dfa414c6 | /lib/gd.h/level_nodes/GJSearchObject.h | 3cc341f06de1d7039015cf4fabbc6b7f488f5ae4 | [
"MIT"
] | permissive | Bryan0810/miniHack | 365819040b3240ae0e27b694d9ecb06f932e6a6a | aad7acc802f78f1963f4b090327dcf64795a0a1d | refs/heads/main | 2023-07-11T17:06:30.017443 | 2021-08-26T02:05:38 | 2021-08-26T02:05:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,286 | h | #ifndef __GJSEARCHOBJECT_H__
#define __GJSEARCHOBJECT_H__
#include <gd.h>
namespace gd {
enum SearchType {
kSearchTypeSearch = 0,
kSearchTypeMostDownloaded = 1,
kSearchTypeMostLiked = 2,
kSearchTypeTrending = 3,
kSearchTypeRecent = 4,
kSearchTypeUsersLevels = 5,
kSearchTypeFeatured = 6,
kSearchTypeMagic = 7,
kSearchTypeMapPacks = 9,
kSearchTypeAwarded = 11,
kSearchTypeFollowed = 12,
kSearchTypeFriends = 13,
kSearchTypeFindUsers = 14,
kSearchTypeHallOfFame = 16,
kSearchTypeMyLevels = 98,
kSearchTypeSavedLevels = 99,
};
class GJSearchObject : public cocos2d::CCNode {
public:
SearchType m_nScreenID;
PAD(96);
int currentFolder; // might be unsigned, but then again its robtop
static GJSearchObject* create(SearchType nID) {
return reinterpret_cast<GJSearchObject*(__fastcall*)(SearchType)>(
gd::base + 0xc2b90
)(nID);
}
SearchType getType() {
return this->m_nScreenID;
}
};
}
#endif
| [
"noreply@github.com"
] | noreply@github.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.