hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
109
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
sequencelengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
sequencelengths 1
9
| max_issues_count
int64 1
48.5k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
sequencelengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2972e23f812deffb1c24b4b95ce84b839f8c37be | 286 | hpp | C++ | worker/include/RTC/RemoteBitrateEstimator/BandwidthUsage.hpp | kicyao/mediasoup | ca8e2d5b57aa2b0d1e5812bb28782d858cd669c6 | [
"0BSD"
] | null | null | null | worker/include/RTC/RemoteBitrateEstimator/BandwidthUsage.hpp | kicyao/mediasoup | ca8e2d5b57aa2b0d1e5812bb28782d858cd669c6 | [
"0BSD"
] | null | null | null | worker/include/RTC/RemoteBitrateEstimator/BandwidthUsage.hpp | kicyao/mediasoup | ca8e2d5b57aa2b0d1e5812bb28782d858cd669c6 | [
"0BSD"
] | null | null | null | #ifndef MS_RTC_REMOTE_BITRATE_ESTIMATOR_BANDWIDTH_USAGE_HPP
#define MS_RTC_REMOTE_BITRATE_ESTIMATOR_BANDWIDTH_USAGE_HPP
// webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h
namespace RTC
{
enum BandwidthUsage
{
kBwNormal,
kBwUnderusing,
kBwOverusing
};
}
#endif
| 16.823529 | 64 | 0.835664 | kicyao |
2973abec041a836ec48096ee61f42e4ffeeebc83 | 11,983 | cpp | C++ | ndn-cxx/mgmt/dispatcher.cpp | Pesa/ndn-cxx | 0249d71d97b2f1f5313f24cec7c84450a795f2ca | [
"OpenSSL"
] | 106 | 2015-01-06T10:08:29.000Z | 2022-02-27T13:40:16.000Z | ndn-cxx/mgmt/dispatcher.cpp | Pesa/ndn-cxx | 0249d71d97b2f1f5313f24cec7c84450a795f2ca | [
"OpenSSL"
] | 6 | 2015-10-15T23:21:06.000Z | 2016-12-20T19:03:10.000Z | ndn-cxx/mgmt/dispatcher.cpp | Pesa/ndn-cxx | 0249d71d97b2f1f5313f24cec7c84450a795f2ca | [
"OpenSSL"
] | 147 | 2015-01-15T15:07:29.000Z | 2022-02-03T13:08:43.000Z | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2013-2021 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
* ndn-cxx library 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.
*
* ndn-cxx 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 Lesser General Public License for more details.
*
* You should have received copies of the GNU General Public License and GNU Lesser
* General Public License along with ndn-cxx, e.g., in COPYING.md file. If not, see
* <http://www.gnu.org/licenses/>.
*
* See AUTHORS.md for complete list of ndn-cxx authors and contributors.
*/
#include "ndn-cxx/mgmt/dispatcher.hpp"
#include "ndn-cxx/lp/tags.hpp"
#include "ndn-cxx/util/logger.hpp"
NDN_LOG_INIT(ndn.mgmt.Dispatcher);
namespace ndn {
namespace mgmt {
Authorization
makeAcceptAllAuthorization()
{
return [] (const Name& prefix,
const Interest& interest,
const ControlParameters* params,
const AcceptContinuation& accept,
const RejectContinuation& reject) {
accept("");
};
}
Dispatcher::Dispatcher(Face& face, KeyChain& keyChain,
const security::SigningInfo& signingInfo,
size_t imsCapacity)
: m_face(face)
, m_keyChain(keyChain)
, m_signingInfo(signingInfo)
, m_storage(m_face.getIoService(), imsCapacity)
{
}
Dispatcher::~Dispatcher() = default;
void
Dispatcher::addTopPrefix(const Name& prefix, bool wantRegister,
const security::SigningInfo& signingInfo)
{
bool hasOverlap = std::any_of(m_topLevelPrefixes.begin(), m_topLevelPrefixes.end(),
[&prefix] (const auto& x) {
return x.first.isPrefixOf(prefix) || prefix.isPrefixOf(x.first);
});
if (hasOverlap) {
NDN_THROW(std::out_of_range("top-level prefix overlaps"));
}
TopPrefixEntry& topPrefixEntry = m_topLevelPrefixes[prefix];
if (wantRegister) {
topPrefixEntry.registeredPrefix = m_face.registerPrefix(prefix,
nullptr,
[] (const Name&, const std::string& reason) {
NDN_THROW(std::runtime_error("prefix registration failed: " + reason));
},
signingInfo);
}
for (const auto& entry : m_handlers) {
Name fullPrefix = Name(prefix).append(entry.first);
auto filterHdl = m_face.setInterestFilter(fullPrefix,
[=, cb = entry.second] (const auto&, const auto& interest) {
cb(prefix, interest);
});
topPrefixEntry.interestFilters.emplace_back(std::move(filterHdl));
}
}
void
Dispatcher::removeTopPrefix(const Name& prefix)
{
m_topLevelPrefixes.erase(prefix);
}
bool
Dispatcher::isOverlappedWithOthers(const PartialName& relPrefix) const
{
bool hasOverlapWithHandlers =
std::any_of(m_handlers.begin(), m_handlers.end(),
[&] (const auto& entry) {
return entry.first.isPrefixOf(relPrefix) || relPrefix.isPrefixOf(entry.first);
});
bool hasOverlapWithStreams =
std::any_of(m_streams.begin(), m_streams.end(),
[&] (const auto& entry) {
return entry.first.isPrefixOf(relPrefix) || relPrefix.isPrefixOf(entry.first);
});
return hasOverlapWithHandlers || hasOverlapWithStreams;
}
void
Dispatcher::afterAuthorizationRejected(RejectReply act, const Interest& interest)
{
if (act == RejectReply::STATUS403) {
sendControlResponse(ControlResponse(403, "authorization rejected"), interest);
}
}
void
Dispatcher::queryStorage(const Name& prefix, const Interest& interest,
const InterestHandler& missContinuation)
{
auto data = m_storage.find(interest);
if (data == nullptr) {
// invoke missContinuation to process this Interest if the query fails.
if (missContinuation)
missContinuation(prefix, interest);
}
else {
// send the fetched data through face if query succeeds.
sendOnFace(*data);
}
}
void
Dispatcher::sendData(const Name& dataName, const Block& content, const MetaInfo& metaInfo,
SendDestination option)
{
auto data = make_shared<Data>(dataName);
data->setContent(content).setMetaInfo(metaInfo).setFreshnessPeriod(1_s);
m_keyChain.sign(*data, m_signingInfo);
if (option == SendDestination::IMS || option == SendDestination::FACE_AND_IMS) {
lp::CachePolicy policy;
policy.setPolicy(lp::CachePolicyType::NO_CACHE);
data->setTag(make_shared<lp::CachePolicyTag>(policy));
m_storage.insert(*data, 1_s);
}
if (option == SendDestination::FACE || option == SendDestination::FACE_AND_IMS) {
sendOnFace(*data);
}
}
void
Dispatcher::sendOnFace(const Data& data)
{
try {
m_face.put(data);
}
catch (const Face::Error& e) {
NDN_LOG_ERROR("sendOnFace(" << data.getName() << "): " << e.what());
}
}
void
Dispatcher::processControlCommandInterest(const Name& prefix,
const Name& relPrefix,
const Interest& interest,
const ControlParametersParser& parser,
const Authorization& authorization,
const AuthorizationAcceptedCallback& accepted,
const AuthorizationRejectedCallback& rejected)
{
// /<prefix>/<relPrefix>/<parameters>
size_t parametersLoc = prefix.size() + relPrefix.size();
const name::Component& pc = interest.getName().get(parametersLoc);
shared_ptr<ControlParameters> parameters;
try {
parameters = parser(pc);
}
catch (const tlv::Error&) {
return;
}
AcceptContinuation accept = [=] (const auto& req) { accepted(req, prefix, interest, parameters); };
RejectContinuation reject = [=] (RejectReply reply) { rejected(reply, interest); };
authorization(prefix, interest, parameters.get(), accept, reject);
}
void
Dispatcher::processAuthorizedControlCommandInterest(const std::string& requester,
const Name& prefix,
const Interest& interest,
const shared_ptr<ControlParameters>& parameters,
const ValidateParameters& validateParams,
const ControlCommandHandler& handler)
{
if (validateParams(*parameters)) {
handler(prefix, interest, *parameters,
[=] (const auto& resp) { this->sendControlResponse(resp, interest); });
}
else {
sendControlResponse(ControlResponse(400, "failed in validating parameters"), interest);
}
}
void
Dispatcher::sendControlResponse(const ControlResponse& resp, const Interest& interest, bool isNack)
{
MetaInfo metaInfo;
if (isNack) {
metaInfo.setType(tlv::ContentType_Nack);
}
// control response is always sent out through the face
sendData(interest.getName(), resp.wireEncode(), metaInfo, SendDestination::FACE);
}
void
Dispatcher::addStatusDataset(const PartialName& relPrefix,
Authorization authorize,
StatusDatasetHandler handle)
{
if (!m_topLevelPrefixes.empty()) {
NDN_THROW(std::domain_error("one or more top-level prefix has been added"));
}
if (isOverlappedWithOthers(relPrefix)) {
NDN_THROW(std::out_of_range("status dataset name overlaps"));
}
AuthorizationAcceptedCallback accepted =
std::bind(&Dispatcher::processAuthorizedStatusDatasetInterest, this, _2, _3, std::move(handle));
AuthorizationRejectedCallback rejected = [this] (auto&&... args) {
afterAuthorizationRejected(std::forward<decltype(args)>(args)...);
};
// follow the general path if storage is a miss
InterestHandler missContinuation = std::bind(&Dispatcher::processStatusDatasetInterest, this, _1, _2,
std::move(authorize), std::move(accepted), std::move(rejected));
m_handlers[relPrefix] = [this, miss = std::move(missContinuation)] (auto&&... args) {
this->queryStorage(std::forward<decltype(args)>(args)..., miss);
};
}
void
Dispatcher::processStatusDatasetInterest(const Name& prefix,
const Interest& interest,
const Authorization& authorization,
const AuthorizationAcceptedCallback& accepted,
const AuthorizationRejectedCallback& rejected)
{
const Name& interestName = interest.getName();
bool endsWithVersionOrSegment = interestName.size() >= 1 &&
(interestName[-1].isVersion() || interestName[-1].isSegment());
if (endsWithVersionOrSegment) {
return;
}
AcceptContinuation accept = [=] (const auto& req) { accepted(req, prefix, interest, nullptr); };
RejectContinuation reject = [=] (RejectReply reply) { rejected(reply, interest); };
authorization(prefix, interest, nullptr, accept, reject);
}
void
Dispatcher::processAuthorizedStatusDatasetInterest(const Name& prefix,
const Interest& interest,
const StatusDatasetHandler& handler)
{
StatusDatasetContext context(interest,
[this] (auto&&... args) {
sendStatusDatasetSegment(std::forward<decltype(args)>(args)...);
},
[this, interest] (auto&&... args) {
sendControlResponse(std::forward<decltype(args)>(args)..., interest, true);
});
handler(prefix, interest, context);
}
void
Dispatcher::sendStatusDatasetSegment(const Name& dataName, const Block& content, bool isFinalBlock)
{
// the first segment will be sent to both places (the face and the in-memory storage)
// other segments will be inserted to the in-memory storage only
auto destination = SendDestination::IMS;
if (dataName[-1].toSegment() == 0) {
destination = SendDestination::FACE_AND_IMS;
}
MetaInfo metaInfo;
if (isFinalBlock) {
metaInfo.setFinalBlock(dataName[-1]);
}
sendData(dataName, content, metaInfo, destination);
}
PostNotification
Dispatcher::addNotificationStream(const PartialName& relPrefix)
{
if (!m_topLevelPrefixes.empty()) {
NDN_THROW(std::domain_error("one or more top-level prefix has been added"));
}
if (isOverlappedWithOthers(relPrefix)) {
NDN_THROW(std::out_of_range("notification stream name overlaps"));
}
// register a handler for the subscriber of this notification stream
// keep silent if Interest does not match a stored notification
m_handlers[relPrefix] = [this] (auto&&... args) {
this->queryStorage(std::forward<decltype(args)>(args)..., nullptr);
};
m_streams[relPrefix] = 0;
return [=] (const Block& b) { postNotification(b, relPrefix); };
}
void
Dispatcher::postNotification(const Block& notification, const PartialName& relPrefix)
{
if (m_topLevelPrefixes.size() != 1) {
NDN_LOG_WARN("postNotification: no top-level prefix or too many top-level prefixes");
return;
}
Name streamName(m_topLevelPrefixes.begin()->first);
streamName.append(relPrefix);
streamName.appendSequenceNumber(m_streams[streamName]++);
// notification is sent out via the face after inserting into the in-memory storage,
// because a request may be pending in the PIT
sendData(streamName, notification, {}, SendDestination::FACE_AND_IMS);
}
} // namespace mgmt
} // namespace ndn
| 35.038012 | 111 | 0.650505 | Pesa |
2976df73404b8968457f536ada57c1d80954d318 | 432 | cc | C++ | function_ref/snippets/snippet-function_ref-private-spec.cc | descender76/cpp_proposals | 2eb7e2f59257b376dadd1b66464e076c3de23ab1 | [
"BSL-1.0"
] | 1 | 2022-01-21T20:10:46.000Z | 2022-01-21T20:10:46.000Z | function_ref/snippets/snippet-function_ref-private-spec.cc | descender76/cpp_proposals | 2eb7e2f59257b376dadd1b66464e076c3de23ab1 | [
"BSL-1.0"
] | null | null | null | function_ref/snippets/snippet-function_ref-private-spec.cc | descender76/cpp_proposals | 2eb7e2f59257b376dadd1b66464e076c3de23ab1 | [
"BSL-1.0"
] | null | null | null | // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0792r5.html
namespace std
{
template <typename Signature>
class function_ref
{
void* erased_object; // exposition only
R(*erased_function)(Args...); // exposition only
// `R`, and `Args...` are the return type, and the parameter-type-list,
// of the function type `Signature`, respectively.
// ...
};
// ...
} | 25.411765 | 79 | 0.597222 | descender76 |
29791ba3fca8189692e6356aa096de29d121ca99 | 22,025 | hpp | C++ | boost/boost/move/detail/fwd_macros.hpp | tonystone/geofeatures | 25aca530a9140b3f259e9ee0833c93522e83a697 | [
"BSL-1.0",
"Apache-2.0"
] | 24 | 2015-08-25T05:35:37.000Z | 2020-10-24T14:21:59.000Z | boost/boost/move/detail/fwd_macros.hpp | tonystone/geofeatures | 25aca530a9140b3f259e9ee0833c93522e83a697 | [
"BSL-1.0",
"Apache-2.0"
] | 97 | 2015-08-25T16:11:16.000Z | 2019-03-17T00:54:32.000Z | boost/boost/move/detail/fwd_macros.hpp | tonystone/geofeatures | 25aca530a9140b3f259e9ee0833c93522e83a697 | [
"BSL-1.0",
"Apache-2.0"
] | 9 | 2015-08-26T03:11:38.000Z | 2018-03-21T07:16:29.000Z | //////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2014-2014. 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)
//
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_MOVE_DETAIL_FWD_MACROS_HPP
#define BOOST_MOVE_DETAIL_FWD_MACROS_HPP
#ifndef BOOST_CONFIG_HPP
# include <boost/config.hpp>
#endif
#
#if defined(BOOST_HAS_PRAGMA_ONCE)
# pragma once
#endif
#include <boost/move/detail/workaround.hpp>
namespace geofeatures_boost {} namespace boost = geofeatures_boost; namespace geofeatures_boost {
namespace move_detail {
template <typename T> struct unvoid { typedef T type; };
template <> struct unvoid<void> { struct type { }; };
template <> struct unvoid<const void> { struct type { }; };
} //namespace move_detail {
} //namespace geofeatures_boost {} namespace boost = geofeatures_boost; namespace geofeatures_boost {
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#if defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
namespace geofeatures_boost {} namespace boost = geofeatures_boost; namespace geofeatures_boost {
namespace move_detail {
template<class T>
struct mref;
template<class T>
struct mref<T &>
{
explicit mref(T &t) : t_(t){}
T &t_;
T & get() { return t_; }
};
template<class T>
struct mref
{
explicit mref(T &&t) : t_(t) {}
T &t_;
T &&get() { return ::geofeatures_boost::move(t_); }
};
} //namespace move_detail {
} //namespace geofeatures_boost {} namespace boost = geofeatures_boost; namespace geofeatures_boost {
#endif //BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
#endif //!defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
//BOOST_MOVE_REPEATN(MACRO)
#define BOOST_MOVE_REPEAT0(MACRO)
#define BOOST_MOVE_REPEAT1(MACRO) MACRO
#define BOOST_MOVE_REPEAT2(MACRO) BOOST_MOVE_REPEAT1(MACRO), MACRO
#define BOOST_MOVE_REPEAT3(MACRO) BOOST_MOVE_REPEAT2(MACRO), MACRO
#define BOOST_MOVE_REPEAT4(MACRO) BOOST_MOVE_REPEAT3(MACRO), MACRO
#define BOOST_MOVE_REPEAT5(MACRO) BOOST_MOVE_REPEAT4(MACRO), MACRO
#define BOOST_MOVE_REPEAT6(MACRO) BOOST_MOVE_REPEAT5(MACRO), MACRO
#define BOOST_MOVE_REPEAT7(MACRO) BOOST_MOVE_REPEAT6(MACRO), MACRO
#define BOOST_MOVE_REPEAT8(MACRO) BOOST_MOVE_REPEAT7(MACRO), MACRO
#define BOOST_MOVE_REPEAT9(MACRO) BOOST_MOVE_REPEAT8(MACRO), MACRO
//BOOST_MOVE_FWDN
#define BOOST_MOVE_FWD0
#define BOOST_MOVE_FWD1 ::geofeatures_boost::forward<P0>(p0)
#define BOOST_MOVE_FWD2 BOOST_MOVE_FWD1, ::geofeatures_boost::forward<P1>(p1)
#define BOOST_MOVE_FWD3 BOOST_MOVE_FWD2, ::geofeatures_boost::forward<P2>(p2)
#define BOOST_MOVE_FWD4 BOOST_MOVE_FWD3, ::geofeatures_boost::forward<P3>(p3)
#define BOOST_MOVE_FWD5 BOOST_MOVE_FWD4, ::geofeatures_boost::forward<P4>(p4)
#define BOOST_MOVE_FWD6 BOOST_MOVE_FWD5, ::geofeatures_boost::forward<P5>(p5)
#define BOOST_MOVE_FWD7 BOOST_MOVE_FWD6, ::geofeatures_boost::forward<P6>(p6)
#define BOOST_MOVE_FWD8 BOOST_MOVE_FWD7, ::geofeatures_boost::forward<P7>(p7)
#define BOOST_MOVE_FWD9 BOOST_MOVE_FWD8, ::geofeatures_boost::forward<P8>(p8)
//BOOST_MOVE_FWDQN
#define BOOST_MOVE_FWDQ0
#define BOOST_MOVE_FWDQ1 ::geofeatures_boost::forward<Q0>(q0)
#define BOOST_MOVE_FWDQ2 BOOST_MOVE_FWDQ1, ::geofeatures_boost::forward<Q1>(q1)
#define BOOST_MOVE_FWDQ3 BOOST_MOVE_FWDQ2, ::geofeatures_boost::forward<Q2>(q2)
#define BOOST_MOVE_FWDQ4 BOOST_MOVE_FWDQ3, ::geofeatures_boost::forward<Q3>(q3)
#define BOOST_MOVE_FWDQ5 BOOST_MOVE_FWDQ4, ::geofeatures_boost::forward<Q4>(q4)
#define BOOST_MOVE_FWDQ6 BOOST_MOVE_FWDQ5, ::geofeatures_boost::forward<Q5>(q5)
#define BOOST_MOVE_FWDQ7 BOOST_MOVE_FWDQ6, ::geofeatures_boost::forward<Q6>(q6)
#define BOOST_MOVE_FWDQ8 BOOST_MOVE_FWDQ7, ::geofeatures_boost::forward<Q7>(q7)
#define BOOST_MOVE_FWDQ9 BOOST_MOVE_FWDQ8, ::geofeatures_boost::forward<Q8>(q8)
//BOOST_MOVE_ARGN
#define BOOST_MOVE_ARG0
#define BOOST_MOVE_ARG1 p0
#define BOOST_MOVE_ARG2 BOOST_MOVE_ARG1, p1
#define BOOST_MOVE_ARG3 BOOST_MOVE_ARG2, p2
#define BOOST_MOVE_ARG4 BOOST_MOVE_ARG3, p3
#define BOOST_MOVE_ARG5 BOOST_MOVE_ARG4, p4
#define BOOST_MOVE_ARG6 BOOST_MOVE_ARG5, p5
#define BOOST_MOVE_ARG7 BOOST_MOVE_ARG6, p6
#define BOOST_MOVE_ARG8 BOOST_MOVE_ARG7, p7
#define BOOST_MOVE_ARG9 BOOST_MOVE_ARG8, p8
//BOOST_MOVE_DECLVALN
#define BOOST_MOVE_DECLVAL0
#define BOOST_MOVE_DECLVAL1 ::geofeatures_boost::move_detail::declval<P0>()
#define BOOST_MOVE_DECLVAL2 BOOST_MOVE_DECLVAL1, ::geofeatures_boost::move_detail::declval<P1>()
#define BOOST_MOVE_DECLVAL3 BOOST_MOVE_DECLVAL2, ::geofeatures_boost::move_detail::declval<P2>()
#define BOOST_MOVE_DECLVAL4 BOOST_MOVE_DECLVAL3, ::geofeatures_boost::move_detail::declval<P3>()
#define BOOST_MOVE_DECLVAL5 BOOST_MOVE_DECLVAL4, ::geofeatures_boost::move_detail::declval<P4>()
#define BOOST_MOVE_DECLVAL6 BOOST_MOVE_DECLVAL5, ::geofeatures_boost::move_detail::declval<P5>()
#define BOOST_MOVE_DECLVAL7 BOOST_MOVE_DECLVAL6, ::geofeatures_boost::move_detail::declval<P6>()
#define BOOST_MOVE_DECLVAL8 BOOST_MOVE_DECLVAL7, ::geofeatures_boost::move_detail::declval<P7>()
#define BOOST_MOVE_DECLVAL9 BOOST_MOVE_DECLVAL8, ::geofeatures_boost::move_detail::declval<P8>()
#ifdef BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
#define BOOST_MOVE_MREF(T) ::geofeatures_boost::move_detail::mref<T>
#define BOOST_MOVE_MFWD(N) ::geofeatures_boost::forward<P##N>(this->m_p##N.get())
#else
#define BOOST_MOVE_MREF(T) BOOST_FWD_REF(T)
#define BOOST_MOVE_MFWD(N) ::geofeatures_boost::forward<P##N>(this->m_p##N)
#endif
#define BOOST_MOVE_MITFWD(N) *this->m_p##N
#define BOOST_MOVE_MINC(N) ++this->m_p##N
//BOOST_MOVE_MFWDN
#define BOOST_MOVE_MFWD0
#define BOOST_MOVE_MFWD1 BOOST_MOVE_MFWD(0)
#define BOOST_MOVE_MFWD2 BOOST_MOVE_MFWD1, BOOST_MOVE_MFWD(1)
#define BOOST_MOVE_MFWD3 BOOST_MOVE_MFWD2, BOOST_MOVE_MFWD(2)
#define BOOST_MOVE_MFWD4 BOOST_MOVE_MFWD3, BOOST_MOVE_MFWD(3)
#define BOOST_MOVE_MFWD5 BOOST_MOVE_MFWD4, BOOST_MOVE_MFWD(4)
#define BOOST_MOVE_MFWD6 BOOST_MOVE_MFWD5, BOOST_MOVE_MFWD(5)
#define BOOST_MOVE_MFWD7 BOOST_MOVE_MFWD6, BOOST_MOVE_MFWD(6)
#define BOOST_MOVE_MFWD8 BOOST_MOVE_MFWD7, BOOST_MOVE_MFWD(7)
#define BOOST_MOVE_MFWD9 BOOST_MOVE_MFWD8, BOOST_MOVE_MFWD(8)
//BOOST_MOVE_MINCN
#define BOOST_MOVE_MINC0
#define BOOST_MOVE_MINC1 BOOST_MOVE_MINC(0)
#define BOOST_MOVE_MINC2 BOOST_MOVE_MINC1, BOOST_MOVE_MINC(1)
#define BOOST_MOVE_MINC3 BOOST_MOVE_MINC2, BOOST_MOVE_MINC(2)
#define BOOST_MOVE_MINC4 BOOST_MOVE_MINC3, BOOST_MOVE_MINC(3)
#define BOOST_MOVE_MINC5 BOOST_MOVE_MINC4, BOOST_MOVE_MINC(4)
#define BOOST_MOVE_MINC6 BOOST_MOVE_MINC5, BOOST_MOVE_MINC(5)
#define BOOST_MOVE_MINC7 BOOST_MOVE_MINC6, BOOST_MOVE_MINC(6)
#define BOOST_MOVE_MINC8 BOOST_MOVE_MINC7, BOOST_MOVE_MINC(7)
#define BOOST_MOVE_MINC9 BOOST_MOVE_MINC8, BOOST_MOVE_MINC(8)
//BOOST_MOVE_MITFWDN
#define BOOST_MOVE_MITFWD0
#define BOOST_MOVE_MITFWD1 BOOST_MOVE_MITFWD(0)
#define BOOST_MOVE_MITFWD2 BOOST_MOVE_MITFWD1, BOOST_MOVE_MITFWD(1)
#define BOOST_MOVE_MITFWD3 BOOST_MOVE_MITFWD2, BOOST_MOVE_MITFWD(2)
#define BOOST_MOVE_MITFWD4 BOOST_MOVE_MITFWD3, BOOST_MOVE_MITFWD(3)
#define BOOST_MOVE_MITFWD5 BOOST_MOVE_MITFWD4, BOOST_MOVE_MITFWD(4)
#define BOOST_MOVE_MITFWD6 BOOST_MOVE_MITFWD5, BOOST_MOVE_MITFWD(5)
#define BOOST_MOVE_MITFWD7 BOOST_MOVE_MITFWD6, BOOST_MOVE_MITFWD(6)
#define BOOST_MOVE_MITFWD8 BOOST_MOVE_MITFWD7, BOOST_MOVE_MITFWD(7)
#define BOOST_MOVE_MITFWD9 BOOST_MOVE_MITFWD8, BOOST_MOVE_MITFWD(8)
//BOOST_MOVE_FWD_INITN
#define BOOST_MOVE_FWD_INIT0
#define BOOST_MOVE_FWD_INIT1 m_p0(::geofeatures_boost::forward<P0>(p0))
#define BOOST_MOVE_FWD_INIT2 BOOST_MOVE_FWD_INIT1, m_p1(::geofeatures_boost::forward<P1>(p1))
#define BOOST_MOVE_FWD_INIT3 BOOST_MOVE_FWD_INIT2, m_p2(::geofeatures_boost::forward<P2>(p2))
#define BOOST_MOVE_FWD_INIT4 BOOST_MOVE_FWD_INIT3, m_p3(::geofeatures_boost::forward<P3>(p3))
#define BOOST_MOVE_FWD_INIT5 BOOST_MOVE_FWD_INIT4, m_p4(::geofeatures_boost::forward<P4>(p4))
#define BOOST_MOVE_FWD_INIT6 BOOST_MOVE_FWD_INIT5, m_p5(::geofeatures_boost::forward<P5>(p5))
#define BOOST_MOVE_FWD_INIT7 BOOST_MOVE_FWD_INIT6, m_p6(::geofeatures_boost::forward<P6>(p6))
#define BOOST_MOVE_FWD_INIT8 BOOST_MOVE_FWD_INIT7, m_p7(::geofeatures_boost::forward<P7>(p7))
#define BOOST_MOVE_FWD_INIT9 BOOST_MOVE_FWD_INIT8, m_p8(::geofeatures_boost::forward<P8>(p8))
//BOOST_MOVE_VAL_INITN
#define BOOST_MOVE_VAL_INIT0
#define BOOST_MOVE_VAL_INIT1 m_p0(p0)
#define BOOST_MOVE_VAL_INIT2 BOOST_MOVE_VAL_INIT1, m_p1(p1)
#define BOOST_MOVE_VAL_INIT3 BOOST_MOVE_VAL_INIT2, m_p2(p2)
#define BOOST_MOVE_VAL_INIT4 BOOST_MOVE_VAL_INIT3, m_p3(p3)
#define BOOST_MOVE_VAL_INIT5 BOOST_MOVE_VAL_INIT4, m_p4(p4)
#define BOOST_MOVE_VAL_INIT6 BOOST_MOVE_VAL_INIT5, m_p5(p5)
#define BOOST_MOVE_VAL_INIT7 BOOST_MOVE_VAL_INIT6, m_p6(p6)
#define BOOST_MOVE_VAL_INIT8 BOOST_MOVE_VAL_INIT7, m_p7(p7)
#define BOOST_MOVE_VAL_INIT9 BOOST_MOVE_VAL_INIT8, m_p8(p8)
//BOOST_MOVE_UREFN
#define BOOST_MOVE_UREF0
#define BOOST_MOVE_UREF1 BOOST_FWD_REF(P0) p0
#define BOOST_MOVE_UREF2 BOOST_MOVE_UREF1, BOOST_FWD_REF(P1) p1
#define BOOST_MOVE_UREF3 BOOST_MOVE_UREF2, BOOST_FWD_REF(P2) p2
#define BOOST_MOVE_UREF4 BOOST_MOVE_UREF3, BOOST_FWD_REF(P3) p3
#define BOOST_MOVE_UREF5 BOOST_MOVE_UREF4, BOOST_FWD_REF(P4) p4
#define BOOST_MOVE_UREF6 BOOST_MOVE_UREF5, BOOST_FWD_REF(P5) p5
#define BOOST_MOVE_UREF7 BOOST_MOVE_UREF6, BOOST_FWD_REF(P6) p6
#define BOOST_MOVE_UREF8 BOOST_MOVE_UREF7, BOOST_FWD_REF(P7) p7
#define BOOST_MOVE_UREF9 BOOST_MOVE_UREF8, BOOST_FWD_REF(P8) p8
//BOOST_MOVE_VALN
#define BOOST_MOVE_VAL0
#define BOOST_MOVE_VAL1 P0 p0
#define BOOST_MOVE_VAL2 BOOST_MOVE_VAL1, BOOST_FWD_REF(P1) p1
#define BOOST_MOVE_VAL3 BOOST_MOVE_VAL2, BOOST_FWD_REF(P2) p2
#define BOOST_MOVE_VAL4 BOOST_MOVE_VAL3, BOOST_FWD_REF(P3) p3
#define BOOST_MOVE_VAL5 BOOST_MOVE_VAL4, BOOST_FWD_REF(P4) p4
#define BOOST_MOVE_VAL6 BOOST_MOVE_VAL5, BOOST_FWD_REF(P5) p5
#define BOOST_MOVE_VAL7 BOOST_MOVE_VAL6, BOOST_FWD_REF(P6) p6
#define BOOST_MOVE_VAL8 BOOST_MOVE_VAL7, BOOST_FWD_REF(P7) p7
#define BOOST_MOVE_VAL9 BOOST_MOVE_VAL8, BOOST_FWD_REF(P8) p8
//BOOST_MOVE_UREFQN
#define BOOST_MOVE_UREFQ0
#define BOOST_MOVE_UREFQ1 BOOST_FWD_REF(Q0) q0
#define BOOST_MOVE_UREFQ2 BOOST_MOVE_UREFQ1, BOOST_FWD_REF(Q1) q1
#define BOOST_MOVE_UREFQ3 BOOST_MOVE_UREFQ2, BOOST_FWD_REF(Q2) q2
#define BOOST_MOVE_UREFQ4 BOOST_MOVE_UREFQ3, BOOST_FWD_REF(Q3) q3
#define BOOST_MOVE_UREFQ5 BOOST_MOVE_UREFQ4, BOOST_FWD_REF(Q4) q4
#define BOOST_MOVE_UREFQ6 BOOST_MOVE_UREFQ5, BOOST_FWD_REF(Q5) q5
#define BOOST_MOVE_UREFQ7 BOOST_MOVE_UREFQ6, BOOST_FWD_REF(Q6) q6
#define BOOST_MOVE_UREFQ8 BOOST_MOVE_UREFQ7, BOOST_FWD_REF(Q7) q7
#define BOOST_MOVE_UREFQ9 BOOST_MOVE_UREFQ8, BOOST_FWD_REF(Q8) q8
//BOOST_MOVE_CREFN
#define BOOST_MOVE_UNVOIDCREF(T) const typename geofeatures_boost::move_detail::unvoid<T>::type&
#define BOOST_MOVE_CREF0
#define BOOST_MOVE_CREF1 BOOST_MOVE_UNVOIDCREF(P0) p0
#define BOOST_MOVE_CREF2 BOOST_MOVE_CREF1, BOOST_MOVE_UNVOIDCREF(P1) p1
#define BOOST_MOVE_CREF3 BOOST_MOVE_CREF2, BOOST_MOVE_UNVOIDCREF(P2) p2
#define BOOST_MOVE_CREF4 BOOST_MOVE_CREF3, BOOST_MOVE_UNVOIDCREF(P3) p3
#define BOOST_MOVE_CREF5 BOOST_MOVE_CREF4, BOOST_MOVE_UNVOIDCREF(P4) p4
#define BOOST_MOVE_CREF6 BOOST_MOVE_CREF5, BOOST_MOVE_UNVOIDCREF(P5) p5
#define BOOST_MOVE_CREF7 BOOST_MOVE_CREF6, BOOST_MOVE_UNVOIDCREF(P6) p6
#define BOOST_MOVE_CREF8 BOOST_MOVE_CREF7, BOOST_MOVE_UNVOIDCREF(P7) p7
#define BOOST_MOVE_CREF9 BOOST_MOVE_CREF8, BOOST_MOVE_UNVOIDCREF(P8) p8
//BOOST_MOVE_CLASSN
#define BOOST_MOVE_CLASS0
#define BOOST_MOVE_CLASS1 class P0
#define BOOST_MOVE_CLASS2 BOOST_MOVE_CLASS1, class P1
#define BOOST_MOVE_CLASS3 BOOST_MOVE_CLASS2, class P2
#define BOOST_MOVE_CLASS4 BOOST_MOVE_CLASS3, class P3
#define BOOST_MOVE_CLASS5 BOOST_MOVE_CLASS4, class P4
#define BOOST_MOVE_CLASS6 BOOST_MOVE_CLASS5, class P5
#define BOOST_MOVE_CLASS7 BOOST_MOVE_CLASS6, class P6
#define BOOST_MOVE_CLASS8 BOOST_MOVE_CLASS7, class P7
#define BOOST_MOVE_CLASS9 BOOST_MOVE_CLASS8, class P8
//BOOST_MOVE_CLASSQN
#define BOOST_MOVE_CLASSQ0
#define BOOST_MOVE_CLASSQ1 class Q0
#define BOOST_MOVE_CLASSQ2 BOOST_MOVE_CLASSQ1, class Q1
#define BOOST_MOVE_CLASSQ3 BOOST_MOVE_CLASSQ2, class Q2
#define BOOST_MOVE_CLASSQ4 BOOST_MOVE_CLASSQ3, class Q3
#define BOOST_MOVE_CLASSQ5 BOOST_MOVE_CLASSQ4, class Q4
#define BOOST_MOVE_CLASSQ6 BOOST_MOVE_CLASSQ5, class Q5
#define BOOST_MOVE_CLASSQ7 BOOST_MOVE_CLASSQ6, class Q6
#define BOOST_MOVE_CLASSQ8 BOOST_MOVE_CLASSQ7, class Q7
#define BOOST_MOVE_CLASSQ9 BOOST_MOVE_CLASSQ8, class Q8
//BOOST_MOVE_CLASSDFLTN
#define BOOST_MOVE_CLASSDFLT0
#define BOOST_MOVE_CLASSDFLT1 class P0 = void
#define BOOST_MOVE_CLASSDFLT2 BOOST_MOVE_CLASSDFLT1, class P1 = void
#define BOOST_MOVE_CLASSDFLT3 BOOST_MOVE_CLASSDFLT2, class P2 = void
#define BOOST_MOVE_CLASSDFLT4 BOOST_MOVE_CLASSDFLT3, class P3 = void
#define BOOST_MOVE_CLASSDFLT5 BOOST_MOVE_CLASSDFLT4, class P4 = void
#define BOOST_MOVE_CLASSDFLT6 BOOST_MOVE_CLASSDFLT5, class P5 = void
#define BOOST_MOVE_CLASSDFLT7 BOOST_MOVE_CLASSDFLT6, class P6 = void
#define BOOST_MOVE_CLASSDFLT8 BOOST_MOVE_CLASSDFLT7, class P7 = void
#define BOOST_MOVE_CLASSDFLT9 BOOST_MOVE_CLASSDFLT8, class P8 = void
//BOOST_MOVE_TARGN
#define BOOST_MOVE_TARG0
#define BOOST_MOVE_TARG1 P0
#define BOOST_MOVE_TARG2 BOOST_MOVE_TARG1, P1
#define BOOST_MOVE_TARG3 BOOST_MOVE_TARG2, P2
#define BOOST_MOVE_TARG4 BOOST_MOVE_TARG3, P3
#define BOOST_MOVE_TARG5 BOOST_MOVE_TARG4, P4
#define BOOST_MOVE_TARG6 BOOST_MOVE_TARG5, P5
#define BOOST_MOVE_TARG7 BOOST_MOVE_TARG6, P6
#define BOOST_MOVE_TARG8 BOOST_MOVE_TARG7, P7
#define BOOST_MOVE_TARG9 BOOST_MOVE_TARG8, P8
//BOOST_MOVE_FWD_TN
#define BOOST_MOVE_FWD_T0
#define BOOST_MOVE_FWD_T1 typename ::geofeatures_boost::move_detail::forward_type<P0>::type
#define BOOST_MOVE_FWD_T2 BOOST_MOVE_FWD_T1, typename ::geofeatures_boost::move_detail::forward_type<P1>::type
#define BOOST_MOVE_FWD_T3 BOOST_MOVE_FWD_T2, typename ::geofeatures_boost::move_detail::forward_type<P2>::type
#define BOOST_MOVE_FWD_T4 BOOST_MOVE_FWD_T3, typename ::geofeatures_boost::move_detail::forward_type<P3>::type
#define BOOST_MOVE_FWD_T5 BOOST_MOVE_FWD_T4, typename ::geofeatures_boost::move_detail::forward_type<P4>::type
#define BOOST_MOVE_FWD_T6 BOOST_MOVE_FWD_T5, typename ::geofeatures_boost::move_detail::forward_type<P5>::type
#define BOOST_MOVE_FWD_T7 BOOST_MOVE_FWD_T6, typename ::geofeatures_boost::move_detail::forward_type<P6>::type
#define BOOST_MOVE_FWD_T8 BOOST_MOVE_FWD_T7, typename ::geofeatures_boost::move_detail::forward_type<P7>::type
#define BOOST_MOVE_FWD_T9 BOOST_MOVE_FWD_T8, typename ::geofeatures_boost::move_detail::forward_type<P8>::type
//BOOST_MOVE_MREFX
#define BOOST_MOVE_MREF0
#define BOOST_MOVE_MREF1 BOOST_MOVE_MREF(P0) m_p0;
#define BOOST_MOVE_MREF2 BOOST_MOVE_MREF1 BOOST_MOVE_MREF(P1) m_p1;
#define BOOST_MOVE_MREF3 BOOST_MOVE_MREF2 BOOST_MOVE_MREF(P2) m_p2;
#define BOOST_MOVE_MREF4 BOOST_MOVE_MREF3 BOOST_MOVE_MREF(P3) m_p3;
#define BOOST_MOVE_MREF5 BOOST_MOVE_MREF4 BOOST_MOVE_MREF(P4) m_p4;
#define BOOST_MOVE_MREF6 BOOST_MOVE_MREF5 BOOST_MOVE_MREF(P5) m_p5;
#define BOOST_MOVE_MREF7 BOOST_MOVE_MREF6 BOOST_MOVE_MREF(P6) m_p6;
#define BOOST_MOVE_MREF8 BOOST_MOVE_MREF7 BOOST_MOVE_MREF(P7) m_p7;
#define BOOST_MOVE_MREF9 BOOST_MOVE_MREF8 BOOST_MOVE_MREF(P8) m_p8;
//BOOST_MOVE_MEMBX
#define BOOST_MOVE_MEMB0
#define BOOST_MOVE_MEMB1 P0 m_p0;
#define BOOST_MOVE_MEMB2 BOOST_MOVE_MEMB1 P1 m_p1;
#define BOOST_MOVE_MEMB3 BOOST_MOVE_MEMB2 P2 m_p2;
#define BOOST_MOVE_MEMB4 BOOST_MOVE_MEMB3 P3 m_p3;
#define BOOST_MOVE_MEMB5 BOOST_MOVE_MEMB4 P4 m_p4;
#define BOOST_MOVE_MEMB6 BOOST_MOVE_MEMB5 P5 m_p5;
#define BOOST_MOVE_MEMB7 BOOST_MOVE_MEMB6 P6 m_p6;
#define BOOST_MOVE_MEMB8 BOOST_MOVE_MEMB7 P7 m_p7;
#define BOOST_MOVE_MEMB9 BOOST_MOVE_MEMB8 P8 m_p8;
//BOOST_MOVE_TMPL_LTN
#define BOOST_MOVE_TMPL_LT0
#define BOOST_MOVE_TMPL_LT1 template<
#define BOOST_MOVE_TMPL_LT2 BOOST_MOVE_TMPL_LT1
#define BOOST_MOVE_TMPL_LT3 BOOST_MOVE_TMPL_LT1
#define BOOST_MOVE_TMPL_LT4 BOOST_MOVE_TMPL_LT1
#define BOOST_MOVE_TMPL_LT5 BOOST_MOVE_TMPL_LT1
#define BOOST_MOVE_TMPL_LT6 BOOST_MOVE_TMPL_LT1
#define BOOST_MOVE_TMPL_LT7 BOOST_MOVE_TMPL_LT1
#define BOOST_MOVE_TMPL_LT8 BOOST_MOVE_TMPL_LT1
#define BOOST_MOVE_TMPL_LT9 BOOST_MOVE_TMPL_LT1
//BOOST_MOVE_LTN
#define BOOST_MOVE_LT0
#define BOOST_MOVE_LT1 <
#define BOOST_MOVE_LT2 BOOST_MOVE_LT1
#define BOOST_MOVE_LT3 BOOST_MOVE_LT1
#define BOOST_MOVE_LT4 BOOST_MOVE_LT1
#define BOOST_MOVE_LT5 BOOST_MOVE_LT1
#define BOOST_MOVE_LT6 BOOST_MOVE_LT1
#define BOOST_MOVE_LT7 BOOST_MOVE_LT1
#define BOOST_MOVE_LT8 BOOST_MOVE_LT1
#define BOOST_MOVE_LT9 BOOST_MOVE_LT1
//BOOST_MOVE_GTN
#define BOOST_MOVE_GT0
#define BOOST_MOVE_GT1 >
#define BOOST_MOVE_GT2 BOOST_MOVE_GT1
#define BOOST_MOVE_GT3 BOOST_MOVE_GT1
#define BOOST_MOVE_GT4 BOOST_MOVE_GT1
#define BOOST_MOVE_GT5 BOOST_MOVE_GT1
#define BOOST_MOVE_GT6 BOOST_MOVE_GT1
#define BOOST_MOVE_GT7 BOOST_MOVE_GT1
#define BOOST_MOVE_GT8 BOOST_MOVE_GT1
#define BOOST_MOVE_GT9 BOOST_MOVE_GT1
//BOOST_MOVE_LPN
#define BOOST_MOVE_LP0
#define BOOST_MOVE_LP1 (
#define BOOST_MOVE_LP2 BOOST_MOVE_LP1
#define BOOST_MOVE_LP3 BOOST_MOVE_LP1
#define BOOST_MOVE_LP4 BOOST_MOVE_LP1
#define BOOST_MOVE_LP5 BOOST_MOVE_LP1
#define BOOST_MOVE_LP6 BOOST_MOVE_LP1
#define BOOST_MOVE_LP7 BOOST_MOVE_LP1
#define BOOST_MOVE_LP8 BOOST_MOVE_LP1
#define BOOST_MOVE_LP9 BOOST_MOVE_LP1
//BOOST_MOVE_RPN
#define BOOST_MOVE_RP0
#define BOOST_MOVE_RP1 )
#define BOOST_MOVE_RP2 BOOST_MOVE_RP1
#define BOOST_MOVE_RP3 BOOST_MOVE_RP1
#define BOOST_MOVE_RP4 BOOST_MOVE_RP1
#define BOOST_MOVE_RP5 BOOST_MOVE_RP1
#define BOOST_MOVE_RP6 BOOST_MOVE_RP1
#define BOOST_MOVE_RP7 BOOST_MOVE_RP1
#define BOOST_MOVE_RP8 BOOST_MOVE_RP1
#define BOOST_MOVE_RP9 BOOST_MOVE_RP1
//BOOST_MOVE_IN
#define BOOST_MOVE_I0
#define BOOST_MOVE_I1 ,
#define BOOST_MOVE_I2 BOOST_MOVE_I1
#define BOOST_MOVE_I3 BOOST_MOVE_I1
#define BOOST_MOVE_I4 BOOST_MOVE_I1
#define BOOST_MOVE_I5 BOOST_MOVE_I1
#define BOOST_MOVE_I6 BOOST_MOVE_I1
#define BOOST_MOVE_I7 BOOST_MOVE_I1
#define BOOST_MOVE_I8 BOOST_MOVE_I1
#define BOOST_MOVE_I9 BOOST_MOVE_I1
//BOOST_MOVE_COLON
#define BOOST_MOVE_COLON0
#define BOOST_MOVE_COLON1 :
#define BOOST_MOVE_COLON2 BOOST_MOVE_COLON1
#define BOOST_MOVE_COLON3 BOOST_MOVE_COLON1
#define BOOST_MOVE_COLON4 BOOST_MOVE_COLON1
#define BOOST_MOVE_COLON5 BOOST_MOVE_COLON1
#define BOOST_MOVE_COLON6 BOOST_MOVE_COLON1
#define BOOST_MOVE_COLON7 BOOST_MOVE_COLON1
#define BOOST_MOVE_COLON8 BOOST_MOVE_COLON1
#define BOOST_MOVE_COLON9 BOOST_MOVE_COLON1
//BOOST_MOVE_ITERATE_2TON
#define BOOST_MOVE_ITERATE_2TO2(MACROFUNC) MACROFUNC(2)
#define BOOST_MOVE_ITERATE_2TO3(MACROFUNC) BOOST_MOVE_ITERATE_2TO2(MACROFUNC) MACROFUNC(3)
#define BOOST_MOVE_ITERATE_2TO4(MACROFUNC) BOOST_MOVE_ITERATE_2TO3(MACROFUNC) MACROFUNC(4)
#define BOOST_MOVE_ITERATE_2TO5(MACROFUNC) BOOST_MOVE_ITERATE_2TO4(MACROFUNC) MACROFUNC(5)
#define BOOST_MOVE_ITERATE_2TO6(MACROFUNC) BOOST_MOVE_ITERATE_2TO5(MACROFUNC) MACROFUNC(6)
#define BOOST_MOVE_ITERATE_2TO7(MACROFUNC) BOOST_MOVE_ITERATE_2TO6(MACROFUNC) MACROFUNC(7)
#define BOOST_MOVE_ITERATE_2TO8(MACROFUNC) BOOST_MOVE_ITERATE_2TO7(MACROFUNC) MACROFUNC(8)
#define BOOST_MOVE_ITERATE_2TO9(MACROFUNC) BOOST_MOVE_ITERATE_2TO8(MACROFUNC) MACROFUNC(9)
//BOOST_MOVE_ITERATE_1TON
#define BOOST_MOVE_ITERATE_1TO1(MACROFUNC) MACROFUNC(1)
#define BOOST_MOVE_ITERATE_1TO2(MACROFUNC) BOOST_MOVE_ITERATE_1TO1(MACROFUNC) MACROFUNC(2)
#define BOOST_MOVE_ITERATE_1TO3(MACROFUNC) BOOST_MOVE_ITERATE_1TO2(MACROFUNC) MACROFUNC(3)
#define BOOST_MOVE_ITERATE_1TO4(MACROFUNC) BOOST_MOVE_ITERATE_1TO3(MACROFUNC) MACROFUNC(4)
#define BOOST_MOVE_ITERATE_1TO5(MACROFUNC) BOOST_MOVE_ITERATE_1TO4(MACROFUNC) MACROFUNC(5)
#define BOOST_MOVE_ITERATE_1TO6(MACROFUNC) BOOST_MOVE_ITERATE_1TO5(MACROFUNC) MACROFUNC(6)
#define BOOST_MOVE_ITERATE_1TO7(MACROFUNC) BOOST_MOVE_ITERATE_1TO6(MACROFUNC) MACROFUNC(7)
#define BOOST_MOVE_ITERATE_1TO8(MACROFUNC) BOOST_MOVE_ITERATE_1TO7(MACROFUNC) MACROFUNC(8)
#define BOOST_MOVE_ITERATE_1TO9(MACROFUNC) BOOST_MOVE_ITERATE_1TO8(MACROFUNC) MACROFUNC(9)
//BOOST_MOVE_ITERATE_0TON
#define BOOST_MOVE_ITERATE_0TO0(MACROFUNC) MACROFUNC(0)
#define BOOST_MOVE_ITERATE_0TO1(MACROFUNC) BOOST_MOVE_ITERATE_0TO0(MACROFUNC) MACROFUNC(1)
#define BOOST_MOVE_ITERATE_0TO2(MACROFUNC) BOOST_MOVE_ITERATE_0TO1(MACROFUNC) MACROFUNC(2)
#define BOOST_MOVE_ITERATE_0TO3(MACROFUNC) BOOST_MOVE_ITERATE_0TO2(MACROFUNC) MACROFUNC(3)
#define BOOST_MOVE_ITERATE_0TO4(MACROFUNC) BOOST_MOVE_ITERATE_0TO3(MACROFUNC) MACROFUNC(4)
#define BOOST_MOVE_ITERATE_0TO5(MACROFUNC) BOOST_MOVE_ITERATE_0TO4(MACROFUNC) MACROFUNC(5)
#define BOOST_MOVE_ITERATE_0TO6(MACROFUNC) BOOST_MOVE_ITERATE_0TO5(MACROFUNC) MACROFUNC(6)
#define BOOST_MOVE_ITERATE_0TO7(MACROFUNC) BOOST_MOVE_ITERATE_0TO6(MACROFUNC) MACROFUNC(7)
#define BOOST_MOVE_ITERATE_0TO8(MACROFUNC) BOOST_MOVE_ITERATE_0TO7(MACROFUNC) MACROFUNC(8)
#define BOOST_MOVE_ITERATE_0TO9(MACROFUNC) BOOST_MOVE_ITERATE_0TO8(MACROFUNC) MACROFUNC(9)
//BOOST_MOVE_ITERATE_NTON
#define BOOST_MOVE_ITERATE_0TO0(MACROFUNC) MACROFUNC(0)
#define BOOST_MOVE_ITERATE_1TO1(MACROFUNC) MACROFUNC(1)
#define BOOST_MOVE_ITERATE_2TO2(MACROFUNC) MACROFUNC(2)
#define BOOST_MOVE_ITERATE_3TO3(MACROFUNC) MACROFUNC(3)
#define BOOST_MOVE_ITERATE_4TO4(MACROFUNC) MACROFUNC(4)
#define BOOST_MOVE_ITERATE_5TO5(MACROFUNC) MACROFUNC(5)
#define BOOST_MOVE_ITERATE_6TO6(MACROFUNC) MACROFUNC(6)
#define BOOST_MOVE_ITERATE_7TO7(MACROFUNC) MACROFUNC(7)
#define BOOST_MOVE_ITERATE_8TO8(MACROFUNC) MACROFUNC(8)
#define BOOST_MOVE_ITERATE_9TO9(MACROFUNC) MACROFUNC(9)
//BOOST_MOVE_CAT
#define BOOST_MOVE_CAT(a, b) BOOST_MOVE_CAT_I(a, b)
#define BOOST_MOVE_CAT_I(a, b) a ## b
//# define BOOST_MOVE_CAT_I(a, b) BOOST_MOVE_CAT_II(~, a ## b)
//# define BOOST_MOVE_CAT_II(p, res) res
#endif //#ifndef BOOST_MOVE_DETAIL_FWD_MACROS_HPP
| 47.263948 | 110 | 0.835868 | tonystone |
297aba696f17f03a57641ec46460184af9a8c119 | 10,008 | cpp | C++ | engine/audio/allegro.cpp | jpmorris33/ire | d6a0a9468c1f98010c5959be301b717f02336895 | [
"BSD-3-Clause"
] | null | null | null | engine/audio/allegro.cpp | jpmorris33/ire | d6a0a9468c1f98010c5959be301b717f02336895 | [
"BSD-3-Clause"
] | 8 | 2020-03-29T21:03:23.000Z | 2020-04-11T23:28:14.000Z | engine/audio/allegro.cpp | jpmorris33/ire | d6a0a9468c1f98010c5959be301b717f02336895 | [
"BSD-3-Clause"
] | 1 | 2020-06-11T16:54:37.000Z | 2020-06-11T16:54:37.000Z | //
// Sound engine wrappers for Allegro
//
#ifdef USE_ALSOUND
#include <stdlib.h> // atexit(), random
#include <string.h> // String splicing routines
#include <allegro.h>
#include "../ithelib.h"
#include "../console.hpp"
#include "../media.hpp"
#include "../loadfile.hpp"
#include "../sound.h"
#include "../types.h"
#ifdef USE_ALOGG
#include <alogg/alogg.h>
#include <alogg/aloggpth.h>
#include <vorbis/vorbisfile.h>
#endif
// defines
// variables
extern char mus_chan; // Number of music channels
extern char sfx_chan; // Number of effects channels
extern int driftlevel; // Amount of frequency variation
VMINT sf_volume = 63;
VMINT mu_volume = 90;
int Songs=0;
int Waves=0;
static int SoundOn=0;
static char *IsPlaying=NULL;
struct SMTab *wavtab; // Tables of data for each sound and song.
struct SMTab *mustab; // Filled by script.cc
#ifdef USE_ALOGG
static struct alogg_stream *stream=NULL;
static struct alogg_thread *thread=NULL;
static ov_callbacks ogg_vfs;
#endif
// functions
void S_Load(); // Load the sound and music
void S_SoundVolume(); // Set the Sound volume
void S_MusicVolume(); // Set the Music volume
void S_PlaySample(char *s,int v); // Play a sound sample
void S_PlayMusic(char *s); // Play a song
void S_StopMusic(); // Stop the music
static void LoadMusic();
static void LoadWavs();
static void SetSoundVol(int vol);
static void SetMusicVol(int vol);
static int StreamSong_GetVoice();
#ifdef USE_ALOGG
static int ov_iFileClose(void *datasource);
static size_t ov_iFileRead(void *ptr, size_t size, size_t num, void *datasource);
static int ov_iFileSeek(void *datasource, ogg_int64_t pos, int whence);
static long ov_iFileTell(void *datasource);
#endif
// Public code
int S_Init()
{
if(SoundOn) {
return 0;
}
if(install_sound(DIGI_AUTODETECT,MIDI_NONE,NULL)) {
return 0; // Zero success for install_sound
}
#ifdef USE_ALOGG
alogg_init();
memset(&ogg_vfs,0,sizeof(ogg_vfs));
ogg_vfs.read_func = ov_iFileRead;
ogg_vfs.close_func = ov_iFileClose;
ogg_vfs.seek_func = ov_iFileSeek;
ogg_vfs.tell_func = ov_iFileTell;
#endif
SoundOn=1;
// Okay
return 1;
}
void S_Term()
{
if(!SoundOn) {
return;
}
StreamSong_stop();
#ifdef USE_ALOGG
alogg_exit();
#endif
SoundOn=0;
}
/*
* S_Load - Load in the music and samples.
*/
void S_Load()
{
if(!SoundOn) {
return;
}
LoadMusic();
LoadWavs();
}
/*
* S_MusicVolume - Set the music level
*/
void S_MusicVolume(int vol)
{
if(vol < 0) {
vol=0;
}
if(vol > 100) {
vol=100;
}
mu_volume = vol;
SetMusicVol(mu_volume);
return;
}
/*
* S_SoundVolume - Set the effects level
*/
void S_SoundVolume(int vol)
{
if(vol < 0) {
vol=0;
}
if(vol > 100) {
vol=100;
}
sf_volume = vol;
SetSoundVol(sf_volume);
return;
}
/*
* S_PlayMusic - play an ogg stream
*/
void S_PlayMusic(char *name)
{
char filename[1024];
long ctr;
if(!SoundOn) {
return;
}
// Is the music playing? If not, this will clear IsPlaying
S_IsPlaying();
for(ctr=0;ctr<Songs;ctr++) {
if(!istricmp(mustab[ctr].name,name)) {
// If the music is marked Not Present, ignore it (music is optional)
if(mustab[ctr].fname[0] == 0) {
return;
}
// Is it already playing?
if(IsPlaying == mustab[ctr].name) {
return;
}
// Is something else playing?
if(IsPlaying) {
StreamSong_stop();
}
// Otherwise, no excuses
IsPlaying = mustab[ctr].name; // This is playing now
if(!loadfile(mustab[ctr].fname,filename)) {
Bug("S_PlayMusic - could play song %s, could not find file '%s'\n",name,mustab[ctr].fname);
return;
}
if(!StreamSong_start(filename)) {
Bug("S_PlayMusic - could not play song '%s'\n",name);
}
return;
}
}
Bug("S_PlayMusic - could not find song '%s'\n",name);
}
/*
* S_StopMusic - Stop the current song (if any)
*/
void S_StopMusic()
{
StreamSong_stop();
}
/*
* S_PlaySample - play a sound sample.
*/
void S_PlaySample(char *name, int volume)
{
int freq,num,ctr;
if(!SoundOn) {
return;
}
for(ctr=0;ctr<Waves;ctr++) {
if(!istricmp(wavtab[ctr].name,name)) {
freq=1000;
if(!wavtab[ctr].nodrift) {
num = 10 - (rand()%20);
freq+=(num*driftlevel)/10;
}
play_sample(wavtab[ctr].sample,volume,128,freq,0); // vol,pan,freq,loop
return;
}
}
Bug("S_PlaySample- could not find sound '%s'\n",name);
}
//
// Private code hereon
//
/*
* LoadMusic - Make sure the music files are there, else mark as Not Present
*/
void LoadMusic()
{
char filename[1024];
int ctr;
if(!SoundOn) {
return;
}
ilog_printf(" Checking music.. "); // This line is not terminated!
for(ctr=0;ctr<Songs;ctr++) {
if(!loadfile(mustab[ctr].fname,filename)) {
ilog_quiet("Warning: Could not load music file '%s'\n",mustab[ctr].fname);
mustab[ctr].fname[0]=0; // Erase the filename to mark N/A
}
}
ilog_printf("done.\n"); // This terminates the line above
}
/*
* LoadWavs - Load in the sounds
*/
void LoadWavs()
{
char filename[1024];
int ctr;
if(!SoundOn) {
return;
}
// load in each sound
ilog_printf(" Loading sounds"); // This line is not terminated, for the dots
Plot(Waves); // Work out how many dots to print
for(ctr=0;ctr<Waves;ctr++) {
if(!loadfile(wavtab[ctr].fname,filename)) {
ithe_panic("LoadWavs: Cannot open WAV file",wavtab[ctr].fname);
}
wavtab[ctr].sample=iload_wav(filename);
if(!wavtab[ctr].sample) {
ithe_panic("LoadWavs: Invalid WAV file",filename);
}
Plot(0); // Print a dot
}
ilog_printf("\n"); // End the line of dots
}
void SetSoundVol(int vol)
{
int ctr,musvoice;
vol = (vol*255)/100;
// Get channel used by streamer because we don't want to touch that one
musvoice = StreamSong_GetVoice();
for(ctr=0;ctr<256;ctr++) {
if(ctr != musvoice) {
voice_set_volume(ctr,vol);
}
}
}
void SetMusicVol(int vol)
{
int musvoice;
vol = (vol*255)/100;
// Get channel used by streamer
musvoice = StreamSong_GetVoice();
if(musvoice>=0) {
voice_set_volume(musvoice,vol);
}
}
// Stubs for the music engine
int S_IsPlaying()
{
#ifdef USE_ALOGG
if(!stream || !thread || !alogg_is_thread_alive(thread)) {
IsPlaying = NULL;
return 0;
}
#endif
return 1;
}
int StreamSong_start(char *filename)
{
IFILE *ifile;
if(!SoundOn) {
return 0;
}
#ifdef USE_ALOGG
ifile = iopen(filename);
stream = alogg_start_streaming_callbacks((void *)ifile,(struct ov_callbacks *)&ogg_vfs,40960,NULL);
if(!stream) {
return 0;
}
thread = alogg_create_thread(stream);
SetMusicVol(mu_volume);
#endif
return 1;
}
void StreamSong_stop()
{
if(!SoundOn) {
return;
}
IsPlaying = NULL;
#ifdef USE_ALOGG
if(!stream) {
return;
}
if(thread) {
alogg_stop_thread(thread);
while(alogg_is_thread_alive(thread));
alogg_destroy_thread(thread);
thread=NULL;
}
stream=NULL;
#endif
return;
}
int StreamSong_GetVoice()
{
int i,voice=-1;
#ifdef USE_ALOGG
AUDIOSTREAM *audiostream=NULL;
#endif
if(!SoundOn) {
return -1;
}
#ifdef USE_ALOGG
if(!stream) {
return -1;
}
if(!thread) {
return -1;
}
if(!alogg_is_thread_alive(thread)) {
return -1;
}
// Tranquilise the thread while we mess around with it
i=alogg_lock_thread(thread);
if(!i) {
// Get the underlying audio stream structure
audiostream=alogg_get_audio_stream(stream);
if(audiostream) {
// Set the volume level
voice = audiostream->voice;
free_audio_stream_buffer(audiostream);
}
// Leave the thread to wake up
alogg_unlock_thread(thread);
} else {
printf("Alogg thread lock error %d\n",i);
}
#endif
return voice;
}
/*
* Filesystem callbacks for ALOGG/Vorbisfile to use
*/
#ifdef USE_ALOGG
int ov_iFileClose(void *datasource)
{
iclose((IFILE *)datasource);
return 1;
}
size_t ov_iFileRead(void *ptr, size_t size, size_t num, void *datasource)
{
return (size_t)iread((char *)ptr,size*num,(IFILE *)datasource);
}
int ov_iFileSeek(void *datasource, ogg_int64_t pos, int whence)
{
iseek((IFILE *)datasource,(unsigned int)pos,whence);
return 1;
}
long ov_iFileTell(void *datasource)
{
return (long)itell((IFILE *)datasource);
}
#endif
/* load_wav: Taken from Allegro, made to use my filesystem API
* Reads a RIFF WAV format sample file, returning a SAMPLE structure,
* or NULL on error.
*/
SAMPLE *iload_wav(char *filename)
{
IFILE *f;
char buffer[25];
int i;
int length, len;
int freq = 22050;
int bits = 8;
int channels = 1;
signed short s;
SAMPLE *spl = NULL;
*allegro_errno=0;
f = iopen(filename);
if (!f) {
return NULL;
}
iread((unsigned char *)buffer, 12, f); /* check RIFF header */
if (memcmp(buffer, "RIFF", 4) || memcmp(buffer+8, "WAVE", 4)) {
goto getout;
}
while (!ieof(f)) {
if (iread((unsigned char *)buffer, 4, f) != 4) {
break;
}
length = igetl_i(f); /* read chunk length */
if (memcmp(buffer, "fmt ", 4) == 0) {
i = igetsh_i(f); /* should be 1 for PCM data */
length -= 2;
if (i != 1) {
goto getout;
}
channels = igetsh_i(f); /* mono or stereo data */
length -= 2;
if ((channels != 1) && (channels != 2)) {
goto getout;
}
freq = igetl_i(f); /* sample frequency */
length -= 4;
igetl_i(f); /* skip six bytes */
igetsh_i(f);
length -= 6;
bits = igetsh_i(f); /* 8 or 16 bit data? */
length -= 2;
if ((bits != 8) && (bits != 16)) {
goto getout;
}
} else {
if (memcmp(buffer, "data", 4) == 0) {
len = length / channels;
if (bits == 16) {
len /= 2;
}
spl = create_sample(bits, ((channels == 2) ? TRUE : FALSE), freq, len);
if (spl) {
if (bits == 8) {
iread((unsigned char *)spl->data, length, f);
} else {
for (i=0; i<len*channels; i++) {
s = igetsh_i(f);
((signed short *)spl->data)[i] = s^0x8000;
}
}
length = 0;
}
}
}
while (length > 0) { /* skip the remainder of the chunk */
if (igetc(f) == (unsigned char)EOF) {
break;
}
length--;
}
}
getout:
iclose(f);
return spl;
}
#endif
| 16.905405 | 100 | 0.643086 | jpmorris33 |
297b86fd96f873aa7d487aad32e5d6749ab0f63c | 67,207 | cc | C++ | networkio.cc | Luthaf/zeopp | d3fed24fb157583323ece4966f98df293d3fa9a4 | [
"BSD-3-Clause-LBNL"
] | 3 | 2018-05-24T00:42:45.000Z | 2018-05-24T12:34:05.000Z | networkio.cc | Luthaf/zeopp | d3fed24fb157583323ece4966f98df293d3fa9a4 | [
"BSD-3-Clause-LBNL"
] | 1 | 2021-04-23T12:21:33.000Z | 2021-04-23T12:41:03.000Z | networkio.cc | Luthaf/zeopp | d3fed24fb157583323ece4966f98df293d3fa9a4 | [
"BSD-3-Clause-LBNL"
] | null | null | null | #include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <fstream>
#include <string>
#include <sstream>
#include "networkio.h"
#include "string_additions.h"
#include "networkinfo.h"
#include "geometry.h"
#include "symbcalc.h"
#include "zeo_consts.h"
#include "network.h" // Try to eliminate cyclic dependency in future
using namespace std;
/** Identifies the extension and the prefix present in the provided
filename and stores them using the two provided character
pointers. */
void parseFilename(const char * fileName, char *name, char *extension){
string s(fileName);
size_t index = s.find_last_of(".");
if(index == string::npos){
cerr << "Improper input filename " << fileName << "\n";
cerr << "No . extension found. Exiting ..." << "\n";
exit(1);
}
else{
string prefix = s.substr(0, index);
string suffix = s.substr(index + 1);
strncpy(name, prefix.data(), prefix.size()); name[prefix.size()] = '\0';
strncpy(extension, suffix.data(), suffix.size()); extension[suffix.size()] = '\0';
}
}
/** Ensures that the provided file is of type .arc, .car, .cuc, .cssr or .v1 or .cif.
* Otherwise, an error message is displayed and the program is
* aborted. */
bool checkInputFile(char * filename){
string file(filename);
string fileTypes [] = {".cuc", ".arc", ".cssr", ".obcssr", ".v1",".cif",".car",".dlp",".pdb"};
int numTypes = 8;
for(int i = 0; i < numTypes; i++){
if(file.find(fileTypes[i]) != string::npos)
return true;
}
cerr << "Invalid input filename " << filename << "\n" << "Exiting ..." << "\n";
// exit(1);
return false;
}
/** Read the information from the .cif file referred to by filename
and store it within the provided ATOM_NETWORK. */
//void readCIFFile(char *filename, ATOM_NETWORK *cell, bool radial){
bool readCIFFile(char *filename, ATOM_NETWORK *cell, bool radial){
string line;
// Known markers in CIF File if you change the order it will affect the code
string descriptor[] = {"data_",
"_cell_length_a", //case 1
"_cell_length_b", //2
"_cell_length_c", //3
"_cell_angle_alpha", //4
"_cell_angle_beta", //5
"_cell_angle_gamma", //6
"loop_", //7
"_symmetry_equiv_pos_as_xyz", //8
"_space_group_symop_operation_xyz", //9
"_atom_site_label", //10
"_atom_site_type_symbol", //11
"_atom_site_fract_x", //12
"_atom_site_fract_y", //13
"_atom_site_fract_z", //14
"_atom_site_charge", //15
"_symmetry_Int_Tables_number", //16
"_atom_site_Cartn_x", //17
"_atom_site_Cartn_y", //18
"_atom_site_Cartn_z", //19
"_symmetry_equiv_pos_site_id", // 20
"NULL"};
int ndx;
vector<string> list = strAry2StrVec(descriptor);
vector<string> token;
vector<string> sym_x;
vector<string> sym_y;
vector<string> sym_z;
vector<string> atom_label;
vector<string> atom_type;
vector<double> atom_x;
vector<double> atom_y;
vector<double> atom_z;
vector<double> atom_charge;
int symmetry_Int_Table_number = -1; //set to dummy value so we can check if anything was read
bool symmetry_equiv_pos_site_id_Flag = false; // this is to read symmetry lines from lines that have sym. id.
// Try opening the file if it opens proceed with processing
ifstream ciffile;
cout << "Opening File: " << filename << endl;
ciffile.open(filename);
bool read_a = false, read_b = false, read_c = false, read_alpha = false, read_beta = false, read_gamma = false, initialized_cell = false; //keep track of when all cell params are parsed, so the cell can be created
if(ciffile.is_open()) {
while(!ciffile.eof()) {
if(read_a && read_b && read_c && read_alpha && read_beta && read_gamma && !initialized_cell) {cell->initialize(); initialized_cell=true;}
getline(ciffile,line);
//printf("DEBUG: read line %s\n", line.c_str());
token = split(line," ()\r\t");
exception: //I needed an easy way to jump out of the _loop command if an unknown command was found
if (token.size() > 0) {
//Where all non-loop commands should be added
if(token[0].substr(0,5).compare(list[0]) == 0){ //name of unit cell
cell->name=token[0].substr(5);
}
else if (token[0].compare(list[1]) == 0){ //length a
cell->a=convertToDouble(token[1]);
read_a = true;
}
else if (token[0].compare(list[2]) == 0){ //length b
cell->b=convertToDouble(token[1]);
read_b = true;
}
else if (token[0].compare(list[3]) == 0){ //length c
cell->c=convertToDouble(token[1]);
read_c = true;
}
else if (token[0].compare(list[4]) == 0){ //alpha
cell->alpha=convertToDouble(token[1]);
read_alpha = true;
}
else if (token[0].compare(list[5]) == 0){ //beta
cell->beta=convertToDouble(token[1]);
read_beta = true;
}
else if (token[0].compare(list[6]) == 0){ //gamma
cell->gamma=convertToDouble(token[1]);
read_gamma = true;
}
else if (token[0].compare(list[16]) == 0){ //_symmetry_Int_Tables_number
symmetry_Int_Table_number = convertToInt(token[1]);
}
else if (token[0].compare(list[7]) == 0){ //loop_
//printf("DEBUG: inside a \"loop_\" section\n");
vector<string> column_labels;
getline(ciffile,line);
token = split(line," \r\t");
bool tokenized = false, in_loop = true;
if(token.size()>0) tokenized=true;
// while (token[0].at(0)=='_') { //collect all of the collumn labels
while (tokenized && in_loop) { //collect all of the collumn labels
if(token[0].at(0)=='_') {
column_labels.push_back(token[0]);
//printf("DEBUG: within loop, parsed a column header \"%s\"\n", token[0].c_str());
getline(ciffile,line);
//printf("DEBUG: read line \"%s\" - tokenizing ...\n", line.c_str());
token = split(line," \r\t");
if(token.size()<=0) tokenized=false;
} else in_loop = false;
}
if(!tokenized) {
printf("\n#####\n##### WARNING: parsed a loop in cif file, but data was not present\n#####\n\n");
} else {
//printf("DEBUG: exited loop successfully, having read data line \"%s\"\n", line.c_str());
//collecting the data associated with each column and put
// in correct place
token = split(line," ,'\r\t"); //This is needed to split data
bool need_to_convert_to_fractional = false;
while(token.size()>0){
if (token[0].at(0) =='_' || token[0].compare("loop_")==0 || token[0].at(0) == '#'){
goto exception; // unexpected input
}
if (token.size()!=column_labels.size() && column_labels[0].compare(list[8]) != 0 && column_labels[0].compare(list[9]) != 0 && column_labels[0].compare(list[20]) != 0){
goto exception; //unexpected input
}
for (unsigned int i=0; i<column_labels.size(); i++){
switch (strCmpList(list,column_labels[i])){
//printf("SYM DEBUG: checking for symmetry section ...\n");
//Where all loop commands should be added
case 8: //_symmetry_equiv_pos_as_xyz and
case 9: //_space_group_symop_operation_xyz have the same meaning
//printf("SYM DEBUG: symmetry section found!\n");
if (!((token.size()==3&&symmetry_equiv_pos_site_id_Flag==false)||(token.size()==4&&symmetry_equiv_pos_site_id_Flag==true))){
cerr << "Error: Expected 3 strings for _symmetry_equiv_pos_as_xyz (or 4 if _symmetry_equiv_pos_site_id is present)" << endl;
// abort();
ciffile.close();
return false;
}
if(token.size()==3) {
sym_x.push_back(token[0]);
sym_y.push_back(token[1]);
sym_z.push_back(token[2]);}
else {
sym_x.push_back(token[1]);
sym_y.push_back(token[2]);
sym_z.push_back(token[3]);
};
//printf("SYM DEBUG: pushing back %s %s %s\n", token[0].c_str(), token[1].c_str(), token[2].c_str());
break;
case 10:
atom_label.push_back(token[i]);
break;
case 11:
atom_type.push_back(token[i]);
break;
case 12:
atom_x.push_back(trans_to_origuc(convertToDouble(token[i])));
break;
case 13:
atom_y.push_back(trans_to_origuc(convertToDouble(token[i])));
break;
case 14:
atom_z.push_back(trans_to_origuc(convertToDouble(token[i])));
break;
case 15:
atom_charge.push_back(convertToDouble(token[i]));
break;
case 17:
atom_x.push_back(convertToDouble(token[i]));
need_to_convert_to_fractional = true;
break;
case 18:
atom_y.push_back(convertToDouble(token[i]));
need_to_convert_to_fractional = true;
break;
case 19:
atom_z.push_back(convertToDouble(token[i]));
need_to_convert_to_fractional = true;
break;
case 20:
symmetry_equiv_pos_site_id_Flag = true;
break;
}
}
//now we've finished parsing this line, we might need to convert Cartesian to fractional coords
if(need_to_convert_to_fractional) {
Point tempcoor;
int this_ID = atom_x.size()-1;
tempcoor = cell->xyz_to_abc(atom_x.at(this_ID),atom_y.at(this_ID),atom_z.at(this_ID));
//printf("DEBUG: atom at Cartesian %.3f %.3f %.3f written to fractional %.3f %.3f %.3f\n", atom_x.at(this_ID),atom_y.at(this_ID),atom_z.at(this_ID), tempcoor[0], tempcoor[1], tempcoor[2]);
atom_x.at(this_ID) = tempcoor[0];
atom_y.at(this_ID) = tempcoor[1];
atom_z.at(this_ID) = tempcoor[2];
}
getline(ciffile,line);
token = split(line," ',\r\t");
}
column_labels.clear();
}
}
token.clear();
}
}
ciffile.close();
//If no symmetry info was provided, we can assume that none is required (i.e., structure has 'P 1' symmetry), ONLY IF we did not read a symmetry_Int_Tables_Number!=1
if (sym_x.size()==0 || sym_y.size()==0 || sym_z.size()==0){
//no symmetry provided
if (symmetry_Int_Table_number>=0 && symmetry_Int_Table_number!=1) {
//read a symmetry table number, but it was not 1
printf("ERROR:\n\tcif file provided no symmetry operations; however, a symmetry_Int_Tables_Number of %d was provided,\n\tindicating symmetry which is not 'P 1' (no symmetry operations);\n\tcannot proceed with insufficient symmetry information\nExiting ...\n", symmetry_Int_Table_number);
// exit(EXIT_FAILURE);
return false;
} else {
sym_x.push_back("x");
sym_y.push_back("y");
sym_z.push_back("z");
}
}
//Now determine whether it is correct to use atom_label or atom_type (atom_label used only if atom_type has no data)
bool CIF_USE_LABEL = atom_type.size()==0;
//Now determine whether charges are used - only if they were provided
bool CIF_CHARGES = atom_charge.size()>0;
//Parse out the numbers from atom labels and types, if specified (defined in network.h)
if (CIF_RMV_NUMS_FROM_ATOM_TYPE){
if (!CIF_USE_LABEL){
for (unsigned int i=0; i<atom_type.size(); i++){
atom_type[i] = split(atom_type[i],"0123456789").at(0);
}
}
else{
for (unsigned int i=0; i<atom_label.size(); i++){
atom_label[i] = split(atom_label[i],"0123456789").at(0);
}
}
}
//Error checking
if (sym_x.size()==0 || sym_y.size()==0 || sym_z.size()==0 ){
cerr << "Error: No .cif symmetry information given" << endl;
cerr << "DEBUG SHOULDN'T HAPPEN" << endl;
return false;
// abort();
}
if (atom_label.size()==0 && CIF_USE_LABEL == true){
cerr << "Error: No ''_atom_site_label'' or ''_atom_site_type_symbol'' information " << endl;
cerr << "This structure appears to be invalid: there are no atom identifying element types or labels - if this is not the case, then this is a bug; please contact the developers." << endl;
return false;
}
if (atom_type.size()==0 && CIF_USE_LABEL == false){
cerr << "Error: No ''_atom_site_type_symbol'' information" << endl;
cerr << "DEBUG SHOULDN'T HAPPEN" << endl;
return false;
// abort();
}
if (atom_x.size()!=atom_y.size() || atom_y.size()!=atom_z.size() || atom_x.size()==0){
cerr << "Error: Atom coordinates not read properly (" << atom_x.size() << " x coords, " << atom_y.size() << " y coords, " << atom_z.size() << " z coords)" << endl;
// abort();
return false;
}
//If no name for the unit cell is given the filename becomes its name
if (cell->name.size() == 0){
cell->name = *filename;
}
//Now to fully assemble the ATOM_NETWORK initialize constructor
// cell->initialize(); //this should now happen much earlier, during parsing
ATOM tempatom;
Point tempcoor;
for (unsigned int i=0; i<atom_x.size(); i++){ //atoms
if (CIF_USE_LABEL){
tempatom.type = atom_label[i];
}
else {
tempatom.type = atom_type[i];
}
tempatom.radius = lookupRadius(tempatom.type, radial);
if(CIF_CHARGES) {
tempatom.charge = atom_charge[i];
} else tempatom.charge = 0;
for (unsigned int j=0;j<sym_x.size(); j++){ //symmetries
tempatom.a_coord = trans_to_origuc(symbCalc(sym_x[j],atom_x[i],atom_y[i],atom_z[i]));
tempatom.b_coord = trans_to_origuc(symbCalc(sym_y[j],atom_x[i],atom_y[i],atom_z[i]));
tempatom.c_coord = trans_to_origuc(symbCalc(sym_z[j],atom_x[i],atom_y[i],atom_z[i]));
tempcoor = cell->abc_to_xyz (tempatom.a_coord,tempatom.b_coord,tempatom.c_coord);
tempatom.x = tempcoor[0];
tempatom.y = tempcoor[1];
tempatom.z = tempcoor[2];
tempatom.specialID = (i*sym_x.size())+j;
//make sure that no duplicate atoms are writen
int match=1;
for (unsigned int k=0;k<cell->atoms.size(); k++){
if(cell->calcDistance(cell->atoms[k],tempatom)<thresholdLarge) { match=0;
/*
if (tempatom.a_coord-thresholdLarge < cell->atoms[k].a_coord && cell->atoms[k].a_coord < tempatom.a_coord+thresholdLarge)
if (tempatom.b_coord-thresholdLarge < cell->atoms[k].b_coord && cell->atoms[k].b_coord < tempatom.b_coord+thresholdLarge )
if (tempatom.c_coord-thresholdLarge < cell->atoms[k].c_coord && cell->atoms[k].c_coord < tempatom.c_coord+thresholdLarge ){
match=0;
*/
}
}
if (match == 1){
cell->atoms.push_back(tempatom);
}
}
}
cell->numAtoms = cell->atoms.size();
}
else{
cout << "Failed to open: " << filename << endl;
ciffile.close();
// exit(1);
return false;
}
return true;
}
/** Read the .arc file refererred to by filename and store its
information within the provided ATOM_NETWORK. */
//void readARCFile(char *filename, ATOM_NETWORK *cell, bool radial){
bool readARCFile(char *filename, ATOM_NETWORK *cell, bool radial){
FILE * input;
input = fopen(filename, "r");
int numAtoms=0;
if(input==NULL){
cout << "\n" << "Failed to open .arc input file " << filename << "\n";
cout << "Exiting ..." << "\n";
// exit(1);
return false;
}
else{
cout << "Reading input file " << filename << "\n";
// Parse down to the FINAL GEOMETRY OBTAINED line
char this_line[500];
char found_final = 0;
while(found_final == 0) {
if(fgets(this_line, 500, input)!=NULL) {
char str1[100], str2[100], str3[100];
int status = sscanf(this_line, "%s %s %s", str1, str2, str3);
if(status!=-1) {
if(strcmp(str1,"FINAL")==0 && strcmp(str2,"GEOMETRY")==0 && strcmp(str3,"OBTAINED")==0) {
found_final = 1;
}
}
} else {
printf("ERROR: finished parsing ARC file before finding geometry section\n");
// exit(EXIT_FAILURE);
fclose(input);
return false;
}
}
// Now parse following lines, trying to extract atom info
int found_atoms = 0;
double x, y, z, charge;
char element[100], str1[100], str2[100], str3[100];
while(found_atoms==0) {
if(fgets(this_line, 500, input)!=NULL) {
int status = sscanf(this_line, "%s %lf %s %lf %s %lf %s %lf", element, &x, str1, &y, str2, &z, str3, &charge);
if(status==8) { //i.e. exactly 8 fields are required to be read
found_atoms = 1;
}
} else {
printf("ERROR: finished parsing ARC file before finding individual atom information\n");
// exit(EXIT_FAILURE);
fclose(input);
return false;
}
}
// At this point, we have the first atom info in memory
ATOM newAtom;
while(found_atoms==1) {
//save previously discovered atom data - just xyz data for now
newAtom.x = x;
newAtom.y = y;
newAtom.z = z;
newAtom.type = string(element);
newAtom.radius = lookupRadius(newAtom.type, radial);
newAtom.charge = charge;
cell->atoms.push_back(newAtom);
numAtoms++;
//try to find next atom data
if(fgets(this_line, 500, input)!=NULL) {
int status = sscanf(this_line, "%s %lf %s %lf %s %lf %s %lf", element, &x, str1, &y, str2, &z, str3, &charge);
if(status!=8) found_atoms = 0; //if we can't read all 8 fields, we have, presumably, reached the unit cell params
} else {
printf("ERROR: finished parsing ARC file before finding unit cell info\n");
// exit(EXIT_FAILURE);
fclose(input);
return false;
}
}
// Now we have read all the atoms, we read the unit cell vectors
XYZ v_a, v_b, v_c;
for(int i=0; i<3; i++) {
if(i==0) {
v_a.x = x; v_a.y = y; v_a.z = z;
} else if(i==1) {
v_b.x = x; v_b.y = y; v_b.z = z;
} else if(i==2) {
v_c.x = x; v_c.y = y; v_c.z = z;
}
if(i!=2) {
if(fgets(this_line, 500, input)!=NULL) {
int status = sscanf(this_line, "%s %lf %s %lf %s %lf %s", element, &x, str1, &y, str2, &z, str3);
if(status!=7) { //didn't read exactly 7 fields
printf("ERROR: could not read exactly three unit cell vectors\n");
// exit(EXIT_FAILURE);
fclose(input);
return false;
}
}
}
}
cell->numAtoms = numAtoms;
fclose(input);
// Set up cell
cell->v_a = v_a;
cell->v_b = v_b;
cell->v_c = v_c;
double alpha = v_b.angle_between(v_c);
double beta = v_a.angle_between(v_c);
double gamma = v_a.angle_between(v_b);
cell->alpha = alpha*360.0/(2.0*PI);
cell->beta = beta*360.0/(2.0*PI);
cell->gamma = gamma*360.0/(2.0*PI); //required since it expects to store degrees
cell->a = v_a.magnitude();
cell->b = v_b.magnitude();
cell->c = v_c.magnitude();
cell->initMatrices();
cell->name = filename;
cell->name.erase(cell->name.end()-4, cell->name.end());
// cout << "number of atoms read " << numAtoms << "\n";
// Convert atom coords to abc and update the xyz values to be within the UC
for(int i=0; i<numAtoms; i++) {
Point newCoords = cell->xyz_to_abc(cell->atoms.at(i).x,cell->atoms.at(i).y,cell->atoms.at(i).z);
cell->atoms.at(i).a_coord = trans_to_origuc(newCoords[0]); cell->atoms.at(i).b_coord = trans_to_origuc(newCoords[1]); cell->atoms.at(i).c_coord = trans_to_origuc(newCoords[2]);
newCoords = cell->abc_to_xyz(cell->atoms.at(i).a_coord,cell->atoms.at(i).b_coord,cell->atoms.at(i).c_coord);
cell->atoms.at(i).x = newCoords[0]; cell->atoms.at(i).y = newCoords[1]; cell->atoms.at(i).z = newCoords[2];
//cout << i << " " << cell->atoms.at(i).type << " " << newCoords[0] << " " << newCoords[1] << " " << newCoords[2] <<"\n";
}
}
return true;
}
/** Read the .cuc file refererred to by filename and store its
information within the provided ATOM_NETWORK. */
//void readCUCFile(char *filename, ATOM_NETWORK *cell, bool radial){
bool readCUCFile(char *filename, ATOM_NETWORK *cell, bool radial){
fstream input;
input.open(filename);
char garbage[256];
int numAtoms;
if(!input.is_open()){
cout << "\n" << "Failed to open .cuc input file " << filename << "\n";
cout << "Exiting ..." << "\n";
// exit(1);
return false;
}
else{
cout << "Reading input file " << filename << "\n";
// Read and store information about the unit cell
cell->name = filename;
cell->name.erase(cell->name.end()-4, cell->name.end());
input.getline(garbage, 256);
input >> garbage;
input >> cell->a >> cell->b >> cell->c;
input >> cell->alpha >> cell->beta >> cell->gamma;
cell->initialize(); // Initializes the unit cell vectors using the
// angles and side lengths
// Read and store information about each atom
numAtoms = 0;
while(!input.eof()){
ATOM newAtom;
input >> newAtom.type;
if(newAtom.type.empty())
break;
changeAtomType(&newAtom); // Converts to atom type
input >> newAtom.a_coord >> newAtom.b_coord >> newAtom.c_coord;
newAtom.a_coord = trans_to_origuc(newAtom.a_coord);
newAtom.b_coord = trans_to_origuc(newAtom.b_coord);
newAtom.c_coord = trans_to_origuc(newAtom.c_coord);
Point newCoords = cell->abc_to_xyz (newAtom.a_coord,newAtom.b_coord,newAtom.c_coord);
newAtom.x = newCoords[0]; newAtom.y = newCoords[1]; newAtom.z = newCoords[2];
newAtom.radius = lookupRadius(newAtom.type, radial);
newAtom.label=newAtom.type;
cell->atoms.push_back(newAtom);
numAtoms++;
}
cell->numAtoms= numAtoms;
input.close();
}
return true;
}
/** Read the information from the .cssr file referred to by filename
and store it within the provided ATOM_NETWORK. */
//void readCSSRFile(char *filename, ATOM_NETWORK *cell, bool radial){
bool readCSSRFile(char *filename, ATOM_NETWORK *cell, bool radial){
string garbage; //this is a garbage string to read line
int i,j;
fstream input;
input.open(filename);
if(input.is_open()==true){
// Read the header information
cout << "Reading input file: " << filename << endl;
input.ignore(38);
input >> cell->a >> cell->b >> cell->c;
getline(input,garbage);
input.ignore(21);
input >> cell->alpha >> cell->beta >> cell->gamma;
getline(input,garbage);
string numStr;
bool longCSSR=false; // this flag wiill enable switching to a different read routine
// to handle files with number of atoms larger than 10000
bool CartCoords=false; // this flag enables reading Cartesian coordinates
input >> numStr >> CartCoords;
getline(input,garbage);
// input >> cell->numAtoms;
if(numStr.compare("****") == 0) longCSSR=true;
// input >> i >> cell->name; // some files have '0' preceeding name
// getline(input,garbage);
getline(input,cell->name);
cell->initialize();
if(longCSSR == false){
cell->numAtoms = atoi(numStr.c_str());
// Read and store information about each atom
for(j=0;j<cell->numAtoms;j++) {
ATOM newAtom;
if(CartCoords==false) {
input >> newAtom.specialID >> newAtom.type >> newAtom.a_coord >> newAtom.b_coord >>newAtom.c_coord;
newAtom.a_coord = trans_to_origuc(newAtom.a_coord);
newAtom.b_coord = trans_to_origuc(newAtom.b_coord);
newAtom.c_coord = trans_to_origuc(newAtom.c_coord);
Point newCoords=cell->abc_to_xyz(newAtom.a_coord,newAtom.b_coord,newAtom.c_coord);
newAtom.x=newCoords[0]; newAtom.y=newCoords[1]; newAtom.z=newCoords[2];}
else{ // read-in cartesian
input >> newAtom.specialID >> newAtom.type >> newAtom.x >> newAtom.y >> newAtom.z;
Point newCoords=cell->xyz_to_abc(newAtom.x,newAtom.y,newAtom.z);
newAtom.a_coord=newCoords[0]; newAtom.b_coord=newCoords[1]; newAtom.c_coord=newCoords[2];
newAtom.a_coord = trans_to_origuc(newAtom.a_coord);
newAtom.b_coord = trans_to_origuc(newAtom.b_coord);
newAtom.c_coord = trans_to_origuc(newAtom.c_coord);
newCoords=cell->abc_to_xyz(newAtom.a_coord,newAtom.b_coord,newAtom.c_coord);
newAtom.x=newCoords[0]; newAtom.y=newCoords[1]; newAtom.z=newCoords[2];
};
newAtom.radius=lookupRadius(newAtom.type, radial);
cell->atoms.push_back(newAtom);
// getline(input,garbage);
//read these numbers after the coords, since the final field contains charge information
int empty_int = 0;
for(int k=0; k<8; k++) input >> empty_int;
input >> newAtom.charge;
}
}
else{ // start longCSSR=true
cout << "Long CSSR file. Switching to another reading routine.\n" ;
int na=1;
while(!input.eof())
{
ATOM newAtom;
newAtom.specialID = na;
input >> garbage;
if(input.eof())
{
na--;
break;
};
if(CartCoords==false) {
input >> newAtom.type >> newAtom.a_coord >> newAtom.b_coord >>newAtom.c_coord;
newAtom.a_coord = trans_to_origuc(newAtom.a_coord);
newAtom.b_coord = trans_to_origuc(newAtom.b_coord);
newAtom.c_coord = trans_to_origuc(newAtom.c_coord);
Point newCoords=cell->abc_to_xyz(newAtom.a_coord,newAtom.b_coord,newAtom.c_coord);
newAtom.x=newCoords[0]; newAtom.y=newCoords[1]; newAtom.z=newCoords[2];}
else{ // input in cartesian
input >> newAtom.type >> newAtom.x >> newAtom.y >> newAtom.z;
Point newCoords=cell->xyz_to_abc(newAtom.x,newAtom.y,newAtom.z);
newAtom.a_coord=newCoords[0]; newAtom.b_coord=newCoords[1]; newAtom.c_coord=newCoords[2];
newAtom.a_coord = trans_to_origuc(newAtom.a_coord);
newAtom.b_coord = trans_to_origuc(newAtom.b_coord);
newAtom.c_coord = trans_to_origuc(newAtom.c_coord);
newCoords=cell->abc_to_xyz(newAtom.a_coord,newAtom.b_coord,newAtom.c_coord);
newAtom.x=newCoords[0]; newAtom.y=newCoords[1]; newAtom.z=newCoords[2];
};
newAtom.radius=lookupRadius(newAtom.type, radial);
//read these numbers after the coords, since the final field contains charge information
int empty_int = 0;
for(int k=0; k<8; k++) input >> empty_int;
input >> newAtom.charge;
cell->atoms.push_back(newAtom);
// cout << na << " " << newAtom.type << " " << newAtom.a_coord << " " << newAtom.b_coord << " " << newAtom.c_coord << endl;
na++;
};
cell->numAtoms = na;
cout << na << " atoms read." << endl;
};// end longCSSR=true
input.close();
}
else{
cerr << "Error: CSSR failed to open " << filename << endl;
// abort();
return false;
}
return true;
}
/** Read the information from the .obcssr file referred to by filename
and store it within the provided ATOM_NETWORK.
obcssr are Open Babel generated cssr files */
bool readOBCSSRFile(char *filename, ATOM_NETWORK *cell, bool radial){
string garbage; //this is a garbage string to read line
int i,j;
fstream input;
input.open(filename);
if(input.is_open()==true){
// Read the header information
cout << "Reading input file: " << filename << endl;;
for(int i=0; i<6; i++) input >> garbage;
input >> cell->a >> cell->b >> cell->c;
getline(input,garbage);
input >> garbage >> garbage;
input >> cell->alpha >> cell->beta >> cell->gamma;
getline(input,garbage);
string numStr;
bool longCSSR=false; // this flag wiill enable switching to a different read routine
// to handle files with number of atoms larger than 10000
bool CartCoords=false; // this flag enables reading Cartesian coordinates
cout << "Attempt to read OpenBabel CSSR file. Atom connectivity and charge columns will be omitted" << endl;
input >> numStr >> CartCoords;
getline(input,garbage);
// input >> cell->numAtoms;
if(numStr.compare("****") == 0) longCSSR=true;
// input >> i >> cell->name; // some files have '0' preceeding name
// getline(input,garbage);
getline(input,cell->name);
cell->initialize();
if(longCSSR == false){
cell->numAtoms = atoi(numStr.c_str());
// Read and store information about each atom
for(j=0;j<cell->numAtoms;j++) {
ATOM newAtom;
if(CartCoords==false) {
input >> newAtom.specialID >> newAtom.type >> newAtom.a_coord >> newAtom.b_coord >>newAtom.c_coord;
newAtom.a_coord = trans_to_origuc(newAtom.a_coord);
newAtom.b_coord = trans_to_origuc(newAtom.b_coord);
newAtom.c_coord = trans_to_origuc(newAtom.c_coord);
Point newCoords=cell->abc_to_xyz(newAtom.a_coord,newAtom.b_coord,newAtom.c_coord);
newAtom.x=newCoords[0]; newAtom.y=newCoords[1]; newAtom.z=newCoords[2];}
else{ // read-in cartesian
input >> newAtom.specialID >> newAtom.type >> newAtom.x >> newAtom.y >> newAtom.z;
Point newCoords=cell->xyz_to_abc(newAtom.x,newAtom.y,newAtom.z);
newAtom.a_coord=newCoords[0]; newAtom.b_coord=newCoords[1]; newAtom.c_coord=newCoords[2];
newAtom.a_coord = trans_to_origuc(newAtom.a_coord);
newAtom.b_coord = trans_to_origuc(newAtom.b_coord);
newAtom.c_coord = trans_to_origuc(newAtom.c_coord);
newCoords=cell->abc_to_xyz(newAtom.a_coord,newAtom.b_coord,newAtom.c_coord);
newAtom.x=newCoords[0]; newAtom.y=newCoords[1]; newAtom.z=newCoords[2];
};
newAtom.radius=lookupRadius(newAtom.type, radial);
cell->atoms.push_back(newAtom);
//uncommented the following line to reads Marcos files
getline(input,garbage);
//read these numbers after the coords, since the final field contains charge information
// int empty_int = 0;
// for(int k=0; k<8; k++) input >> empty_int;
// input >> newAtom.charge;
// TEMP addition to read Marco's cssrs
// input >> empty_int;
}
}
else{ // start longCSSR=true
cout << "Long CSSR file. Switching to another reading routine.\n" ;
int na=1;
while(!input.eof())
{
ATOM newAtom;
newAtom.specialID = na;
input >> garbage;
if(input.eof())
{
na--;
break;
};
if(CartCoords==false) {
input >> newAtom.type >> newAtom.a_coord >> newAtom.b_coord >>newAtom.c_coord;
newAtom.a_coord = trans_to_origuc(newAtom.a_coord);
newAtom.b_coord = trans_to_origuc(newAtom.b_coord);
newAtom.c_coord = trans_to_origuc(newAtom.c_coord);
Point newCoords=cell->abc_to_xyz(newAtom.a_coord,newAtom.b_coord,newAtom.c_coord);
newAtom.x=newCoords[0]; newAtom.y=newCoords[1]; newAtom.z=newCoords[2];}
else{ // input in cartesian
input >> newAtom.type >> newAtom.x >> newAtom.y >> newAtom.z;
Point newCoords=cell->xyz_to_abc(newAtom.x,newAtom.y,newAtom.z);
newAtom.a_coord=newCoords[0]; newAtom.b_coord=newCoords[1]; newAtom.c_coord=newCoords[2];
newAtom.a_coord = trans_to_origuc(newAtom.a_coord);
newAtom.b_coord = trans_to_origuc(newAtom.b_coord);
newAtom.c_coord = trans_to_origuc(newAtom.c_coord);
newCoords=cell->abc_to_xyz(newAtom.a_coord,newAtom.b_coord,newAtom.c_coord);
newAtom.x=newCoords[0]; newAtom.y=newCoords[1]; newAtom.z=newCoords[2];
};
newAtom.radius=lookupRadius(newAtom.type, radial);
//read these numbers after the coords, since the final field contains charge information
int empty_int = 0;
for(int k=0; k<8; k++) input >> empty_int;
input >> newAtom.charge;
cell->atoms.push_back(newAtom);
// TEMP addition to read Marco's cssrs
input >> empty_int;
// cout << na << " " << newAtom.type << " " << newAtom.a_coord << " " << newAtom.b_coord << " " << newAtom.c_coord << endl;
na++;
};
cell->numAtoms = na;
cout << na << " atoms read." << endl;
};// end longCSSR=true
input.close();
}
else{
cerr << "Error: CSSR failed to open " << filename << endl;
// abort();
return false;
}
return true;
}
/** Read the information from the .car file referred to by filename
and store it within the provided ATOM_NETWORK. */
bool readCARFile(char *filename, ATOM_NETWORK *cell, bool radial){
string garbage; //this is a garbage string to read line
int i,j;
fstream input;
input.open(filename);
if(input.is_open()==true){
// Read the header information
cout << "Reading input file: " << filename << endl;
getline(input, garbage); // skip the first comment line
string PBCline;
input >> PBCline; getline(input, garbage);
if(PBCline.compare("PBC=ON") != 0)
{
cerr << "This .car file does not have a periodic structure. Exiting...\n";
return false;
};
getline(input, garbage); // skipping two next lines
getline(input, garbage);
input >> garbage;
input >> cell->a >> cell->b >> cell->c;
input >> cell->alpha >> cell->beta >> cell->gamma;
string SYMMline;
input >> SYMMline;
getline(input,garbage);
if(SYMMline.compare("(P1)") !=0)
{
cerr << "The current .car reader does only work for (P1) symmetry.\n";
return false;
};
cell->name = filename;
cell->initialize();
bool end=false;
int na=0;
while(!end)
{
string str1, str2, str3, str4;
input >> str1;
if(str1.compare("end") == 0 || str1.compare("END") == 0)
{
end = true;
} else
{
ATOM newAtom;
input >> newAtom.x >> newAtom.y >> newAtom.z;
input >> str2 >> str3 >> str4;
input >> newAtom.type >> newAtom.charge;
if(!CAR_USE_ATOM_TYPE_OVER_NAME) newAtom.type = str1;
Point newCoords = cell->xyz_to_abc(newAtom.x, newAtom.y, newAtom.z);
newAtom.a_coord = newCoords[0]; newAtom.b_coord = newCoords[1]; newAtom.c_coord = newCoords[2];
newAtom.radius = lookupRadius(newAtom.type, radial);
cell->atoms.push_back(newAtom);
na++;
};
};
cell->numAtoms = na;
cout << na << " atoms read." << endl;
input.close();
}
else{
cerr << "Error: CAR failed to open " << filename << endl;
// abort();
return false;
}
return true;
}
/** Read the information from the .pdb file referred to by filename
and store it within the provided ATOM_NETWORK.
This function is written to handle example .pdb files from RASPA
*/
bool readPDBFile(char *filename, ATOM_NETWORK *cell, bool radial){
string garbage; //this is a garbage string to read line
int i,j;
fstream input;
input.open(filename);
if(input.is_open()==true){
// Read the header information
cout << "Reading input file: " << filename << endl;
getline(input, garbage); // skip the first comment line
string PBCline;
input >> PBCline;
if(PBCline.compare("CRYST1") != 0)
{
cerr << "This .pdb files does not contain CRYST1 in the second line. File format not compatible. Exiting...\n";
return false;
};
input >> cell->a >> cell->b >> cell->c;
input >> cell->alpha >> cell->beta >> cell->gamma;
getline(input,garbage); // reading rest of line
cell->name = filename;
cell->initialize();
bool end=false;
int na=0;
while(!end)
{
string str1, str2, str3, str4;
input >> str1; // reads ATOM or ENDMDL keyword
if(str1.compare("ENDMDL") == 0)
{
end = true;
} else
{
ATOM newAtom;
input >> str2 ; // reading ID#
input >> newAtom.type;
input >> str4; // reading MDL
input >> newAtom.x >> newAtom.y >> newAtom.z;
input >> str2 >> str3 >> str4; // ignore 2 numbers and a string with label
// if(!CAR_USE_ATOM_TYPE_OVER_NAME) newAtom.type = str1;
Point newCoords = cell->xyz_to_abc(newAtom.x, newAtom.y, newAtom.z);
newAtom.a_coord = newCoords[0]; newAtom.b_coord = newCoords[1]; newAtom.c_coord = newCoords[2];
newAtom.radius = lookupRadius(newAtom.type, radial);
cell->atoms.push_back(newAtom);
na++;
};
};
cell->numAtoms = na;
cout << na << " atoms read." << endl;
input.close();
}
else{
cerr << "Error: PDB failed to open " << filename << endl;
// abort();
return false;
}
return true;
}
/** Read the information from the .v1 file referrred to by filename
and store it within the provided ATOM_NETWORK. */
//void readV1File(char *filename, ATOM_NETWORK *cell, bool radial){
bool readV1File(char *filename, ATOM_NETWORK *cell, bool radial){
fstream input;
char garbage[256];
int i;
input.open(filename);
if(!input.is_open()){
cout<< "Failed to open .v1 file " << filename << "\n";
cout<<"Exiting ..." << "\n";
// exit(1);
return false;
}
else{
cout << "Reading input file " << filename << "\n";
input.getline(garbage, 256);
// Read and store information about the unit cell. While the
// vector components are known, the side lengths and angles remain unknown
input >> garbage >> cell->v_a.x >> cell->v_a.y >> cell->v_a.z;
input >> garbage >> cell->v_b.x >> cell->v_b.y >> cell->v_b.z;
input >> garbage >> cell->v_c.x >> cell->v_c.y >> cell->v_c.z;
input >> cell->numAtoms;
cell->initMatrices();
//Recover information about unit cell angles and side lengths from
//vector components. Essentially reverses the steps performed in
//the initialize() method for ATOM_NETWORK instances as contained
//in the file networkstorage.cc
cell->a = cell->v_a.x;
cell->b = sqrt(cell->v_b.x*cell->v_b.x+cell->v_b.y*cell->v_b.y);
cell->c = sqrt(cell->v_c.x*cell->v_c.x+cell->v_c.y*cell->v_c.y+cell->v_c.z*cell->v_c.z);
cell->beta = acos(cell->v_c.x/cell->c)*360.0/(2.0*PI);
cell->gamma = acos(cell->v_b.x/cell->b)*360.0/(2.0*PI);
cell->alpha = 360.0/(2*PI)*acos((cell->v_c.y/cell->c*sin(2.0*PI*cell->gamma/360.0))
+cos(2.0*PI/360.0*cell->gamma)*cos(2.0*PI/360.0*cell->beta));
// Read and store information about each atom. The coordinates
// relative to the unit cell vectors remain unknown
for(i=0; i<cell->numAtoms; i++){
ATOM newAtom;
input >> newAtom.type >> newAtom.x >> newAtom.y >> newAtom.z;
Point abcCoords = cell->xyz_to_abc(newAtom.x, newAtom.y, newAtom.z);
newAtom.a_coord = trans_to_origuc(abcCoords[0]); newAtom.b_coord = trans_to_origuc(abcCoords[1]); newAtom.c_coord = trans_to_origuc(abcCoords[2]);
newAtom.radius = lookupRadius(newAtom.type, radial);
cell->atoms.push_back(newAtom);
}
input.close();
}
return true;
}
/** Read the information from the .pld file referrred to by filename
and store it within the provided ATOM_NETWORK.
.dlp is a frame from DL_poly HISTORY file */
bool readDLPFile(char *filename, ATOM_NETWORK *cell, bool radial){
fstream input;
char garbage[256];
int i;
input.open(filename);
if(!input.is_open()){
cout<< "Failed to open .dlp file " << filename << "\n";
cout<<"Exiting ..." << "\n";
// exit(1);
return false;
}
else{
cout << "Reading input file " << filename << "\n";
input.getline(garbage, 256);
// Read and store information about the unit cell. While the
// vector components are known, the side lengths and angles remain unknown
input >> cell->v_a.x >> cell->v_a.y >> cell->v_a.z;
input >> cell->v_b.x >> cell->v_b.y >> cell->v_b.z;
input >> cell->v_c.x >> cell->v_c.y >> cell->v_c.z;
// input >> cell->numAtoms;
cell->initMatrices();
//Recover information about unit cell angles and side lengths from
//vector components. Essentially reverses the steps performed in
//the initialize() method for ATOM_NETWORK instances as contained
//in the file networkstorage.cc
cell->a = cell->v_a.x;
cell->b = sqrt(cell->v_b.x*cell->v_b.x+cell->v_b.y*cell->v_b.y);
cell->c = sqrt(cell->v_c.x*cell->v_c.x+cell->v_c.y*cell->v_c.y+cell->v_c.z*cell->v_c.z);
cell->beta = acos(cell->v_c.x/cell->c)*360.0/(2.0*PI);
cell->gamma = acos(cell->v_b.x/cell->b)*360.0/(2.0*PI);
cell->alpha = 360.0/(2*PI)*acos((cell->v_c.y/cell->c*sin(2.0*PI*cell->gamma/360.0))
+cos(2.0*PI/360.0*cell->gamma)*cos(2.0*PI/360.0*cell->beta));
// Read and store information about each atom
int numAtoms = 0;
while(!input.eof()){
ATOM newAtom;
input >> newAtom.type;
if(newAtom.type.empty())
break;
input.getline(garbage,256); // reading remaining data from a line
input >> newAtom.x >> newAtom.y >> newAtom.z;
input.getline(garbage,256); // read end of line
Point newCoords = cell->xyz_to_abc (newAtom.x,newAtom.y,newAtom.z);
newAtom.a_coord = newCoords[0]; newAtom.b_coord = newCoords[1]; newAtom.c_coord = newCoords[2];
newAtom.a_coord = trans_to_origuc(newAtom.a_coord);
newAtom.b_coord = trans_to_origuc(newAtom.b_coord);
newAtom.c_coord = trans_to_origuc(newAtom.c_coord);
newAtom.radius = lookupRadius(newAtom.type, radial);
cell->atoms.push_back(newAtom);
numAtoms++;
}
cell->numAtoms= numAtoms;
input.close();
}
return true;
}
/** Read the VORONOI_NETWORK information located in the provided input stream and
* store it using the provided VORONOI_NETWORK pointer. The input stream must have a file format
* corresponding to a .net or .nt2 format. */
void readNet(istream *input, VORONOI_NETWORK *vornet){
char buff [256];
input->getline(buff,256); // Read line "Vertex table:"
VOR_NODE node;
string garbage;
// Read information about each Voronoi node
int i = 0;
while(true){
(*input) >> garbage;
if(strcmp(garbage.data(), "Edge") == 0)
break;
(*input) >> node.x >> node.y >> node.z >> node.rad_stat_sphere;
// Read node connectivity information
char *connectBuff = new char [256];
char *origBuff = connectBuff;
input->getline(connectBuff,256);
connectBuff+= 1; //Skip space character
char *currentChar = connectBuff;
vector<int> nearestAtoms;
while(true){
if(*currentChar == ' ' || *currentChar == '\0'){
char nextID[256];
strncpy(nextID,connectBuff,currentChar-connectBuff);
nextID[currentChar-connectBuff] = '\0';
nearestAtoms.push_back(atoi(nextID));
connectBuff = currentChar + 1;
}
if(*currentChar == '\0')
break;
currentChar++;
}
delete [] origBuff;
node.atomIDs = nearestAtoms;
vornet->nodes.push_back(node);
i++;
}
input->getline(buff,256); // Reads remainder of line "Edge table:"
//Read information about each Voronoi edge
VOR_EDGE edge;
while(!input->eof()){
(*input) >> edge.from >> garbage >> edge.to >> edge.rad_moving_sphere
>> edge.delta_uc_x >> edge.delta_uc_y >> edge.delta_uc_z >> edge.length;
vornet->edges.push_back(edge);
}
vornet->edges.pop_back();
}
/* Read the VORONOI_NETWORK located in the provided file and store
* it using the provided network pointer. The file must be in the .net/.nt2
* file format. */
//void readNetFile(char * filename, VORONOI_NETWORK *vornet){
bool readNetFile(char * filename, VORONOI_NETWORK *vornet){
fstream input;
input.open(filename);
if(!input.is_open()){
cout<< "Failed to open .nt2 file " << filename << "\n";
cout<<"Exiting ..." << "\n";
// exit(1);
return false;
}
else{
readNet(&input, vornet);
}
return true;
}
/** Write the information within the provided ATOM_NETWORK in a .cssr
file format to the provided filename. */
bool writeToCSSR(char *filename, ATOM_NETWORK *cell){
fstream output;
output.open(filename, fstream::out);
if(!output.is_open()){
cerr << "Error: Failed to open .cssr output file " << filename << endl;
//cerr << "Exiting ..." << "\n";
//exit(1);
return false;
}
else{
cout << "Writing atom network information to " << filename << "\n";
// Write information about the unit cell
output << "\t\t\t\t" << cell->a << " " << cell->b << " " << cell->c << "\n";
output << "\t\t" << cell->alpha<<" "<< cell->beta <<" " << cell->gamma <<" SPGR = 1 P 1\t\t OPT = 1" << "\n";
output << cell->numAtoms << " 0 " << "\n";
output << "0 " << cell->name << "\t" << ": " << cell->name << "\n";
output.setf(ios::fixed, ios::floatfield);
int i;
ATOM atm;
// Write information about each atom
for(i = 0; i<cell->numAtoms; i++){
atm = cell->atoms.at(i);
output << " " << i+1 << " " << cell->atoms.at(i).type << " " << atm.a_coord << " "
<< atm.b_coord << " " << atm.c_coord << " 0 0 0 0 0 0 0 0 " << atm.charge << "\n";
}
output.close();
return true;
}
}
/** Write the information within the provided ATOM_NETWORK in a .cssr
file format to the provided filename, using labels instead of element types. */
bool writeToCSSRLabeled(char *filename, ATOM_NETWORK *cell){
fstream output;
output.open(filename, fstream::out);
if(!output.is_open()){
cerr << "Error: Failed to open .cssr output file " << filename << endl;
//cerr << "Exiting ..." << "\n";
//exit(1);
return false;
}
else{
cout << "Writing atom network information to " << filename << "\n";
// Write information about the unit cell
output << "\t\t\t\t" << cell->a << " " << cell->b << " " << cell->c << "\n";
output << "\t\t" << cell->alpha<<" "<< cell->beta <<" " << cell->gamma <<" SPGR = 1 P 1\t\t OPT = 1" << "\n";
output << cell->numAtoms << " 0 " << "\n";
output << "0 " << cell->name << "\t" << ": " << cell->name << "\n";
output.setf(ios::fixed, ios::floatfield);
int i;
ATOM atm;
// Write information about each atom
for(i = 0; i<cell->numAtoms; i++){
atm = cell->atoms.at(i);
output << " " << i+1 << " " << cell->atoms.at(i).label << " " << atm.a_coord << " "
<< atm.b_coord << " " << atm.c_coord << " 0 0 0 0 0 0 0 0 " << atm.charge << "\n";
}
output.close();
return true;
}
}
/* Computes the formula of the input ATOM_NETWORK and returns it as a c++ string */
string get_formula(ATOM_NETWORK const *const cell)
{
vector<string> atomtypes;
map<string,int> typecount;
for (vector<ATOM>::const_iterator it=cell->atoms.begin(); it!=cell->atoms.end(); ++it){
if (find(atomtypes.begin(), atomtypes.end(), it->type) != atomtypes.end()){
++(typecount[it->type]);
}
else{
atomtypes.push_back(it->type);
typecount[it->type] = 1;
}
}
string formula;
for (map<string,int>::iterator it=typecount.begin(); it!=typecount.end(); ++it){
formula.append(it->first);
stringstream ss;
ss << it->second;
formula.append(ss.str());
}
return formula;
}
/* Generates time stamp */
string get_timestamp()
{
char buff[80];
time_t rawtime;
struct tm* timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
strftime(buff, 80, "%F_%T", timeinfo);
return string(buff);
}
/** Write the infomation within the provided ATOM_NETWORK in a .cif
file format to the provided filename. **/
bool writeToCIF(char *filename, ATOM_NETWORK *cell){
fstream output;
output.open(filename, fstream::out);
if(!output.is_open()){
cerr << "Error: Failed to open .cif output file " << filename << endl;
//cerr << "Exiting ..." << "\n";
//exit(1);
return false;
}
else{
cout << "Writing atom network information to " << filename << "\n";
//output << "data_" << origname << endl; //we need this data_(name) line otherwise the cif file will not be considered valid in some software packages
//Instead of supplying argument to write data_..., using timestamp with number of atoms in the structure
string formula = get_formula(cell);
string time_stamp = get_timestamp();
output << "data_" << formula << "_" << time_stamp << endl;
output << "#******************************************" << endl;
output << "#" << endl;
output << "# CIF file created by Zeo++" << endl;
output << "# Zeo++ is an open source package to" << endl;
output << "# analyze microporous materials" << endl;
output << "#" << endl;
output << "#*******************************************" << "\n\n";
output << "_cell_length_a\t\t" << cell->a << " " << endl; // removed (0)
output << "_cell_length_b\t\t" << cell->b << " " << endl;
output << "_cell_length_c\t\t" << cell->c << " " << endl;
output << "_cell_angle_alpha\t\t" << cell->alpha << " " << endl;
output << "_cell_angle_beta\t\t" << cell->beta << " " << endl;
output << "_cell_angle_gamma\t\t" << cell->gamma << " \n\n";
output << "_symmetry_space_group_name_H-M\t\t" << "'P1'" << endl;
output << "_symmetry_Int_Tables_number\t\t" << "1" << endl;
output << "_symmetry_cell_setting\t\t";
//Determine the Crystal System
if (cell->alpha == 90 && cell->beta == 90 && cell->gamma == 90){
if (cell->a == cell->b || cell->b == cell->c || cell->a == cell->c){
if (cell->a == cell->b && cell->b == cell->c){
output << "Isometric\n" << endl;
}
else {
output << "Tetragonal\n" << endl;
}
}
else{
output << "Orthorhombic\n" << endl;
}
}
else if(cell->alpha == cell->beta || cell->beta == cell->gamma || cell->alpha == cell->gamma){
output << "Monoclinic\n" << endl;
}
else{
output << "Triclinic\n" << endl;
}
output << "loop_" << endl;
output << "_symmetry_equiv_pos_as_xyz" << endl;
output << "'+x,+y,+z'\n" << endl;
output << "loop_" << endl;
output << "_atom_site_label" << endl;
output << "_atom_site_type_symbol" << endl;
output << "_atom_site_fract_x" << endl;
output << "_atom_site_fract_y" << endl;
output << "_atom_site_fract_z" << endl;
for (unsigned int i=0; i<cell->atoms.size(); i++){
ATOM *temp=&(cell->atoms.at(i));
output << temp->specialID << "\t" << temp->type << "\t" << trans_to_origuc(temp->a_coord) << "\t" << trans_to_origuc(temp->b_coord) << "\t" << trans_to_origuc(temp->c_coord) << endl;
}
output.close();
return true;
}
}
/** Write the information within the provided ATOM_NETWORK in a .v1
file format to the provided filename. */
bool writeToV1(char * filename, ATOM_NETWORK *cell){
fstream output;
output.open(filename, fstream::out);
if(!output.is_open()){
cerr << "Error: Failed to open .v1 output file " << filename << endl;
//cerr << "Exiting ..." << "\n";
//exit(1);
return false;
}
else{
cout << "Writing atom network information to " << filename << "\n";
// Write information about the unit cell
output << "Unit cell vectors:" << "\n";
output.precision(8);
output << "va= " << cell->v_a.x << " " << cell->v_a.y << " " << cell->v_a.z << "\n";
output << "vb= " << cell->v_b.x << " " << cell->v_b.y << " " << cell->v_b.z << "\n";
output << "vc= " << cell->v_c.x << " " << cell->v_c.y << " " << cell->v_c.z << "\n";
output << cell->numAtoms << "\n";
// Write information about each atom
vector <ATOM> ::iterator iter = cell->atoms.begin();
while(iter != cell->atoms.end()){
output << iter->type << " " << iter->x << " " << iter->y << " " << iter->z << "\n";
iter++;
}
}
output.close();
return true;
}
/** Write the information stored within the VORONOI_NETWORK in a .nt2
file format to the provided filename. Excludes any nodes or nodes with radii
less than the provided threshold. For the default 0, all nodes and endges are included*/
bool writeToNt2(char *filename, VORONOI_NETWORK *vornet, double minRad){
fstream output;
output.open(filename, fstream::out);
if(!output.is_open()){
cerr << "Error: Failed to open .net2 output file " << filename << "\n";
//cerr << "Exiting ..." << "\n";
//exit(1);
return false;
}
else{
cout << "Writing Voronoi network information to " << filename << "\n";
// Write Voronoi node information
output << "Vertex table:" << "\n";
vector<VOR_NODE> ::iterator niter = vornet->nodes.begin();
int i = 0;
while(niter != vornet->nodes.end()){
if(niter->rad_stat_sphere > minRad){
output << i << " " << niter-> x << " " << niter-> y << " "
<< niter-> z << " " << niter->rad_stat_sphere;
//Write Voronoi node/atom pairing information in i j k....z format
output << " ";
for(unsigned int j = 0; j < niter->atomIDs.size(); j++){
output << niter->atomIDs.at(j);
if(j < niter->atomIDs.size()-1)
output << " ";
}
output << "\n";
}
i++;
niter++;
}
// Write Voronoi edge information
output << "\n" << "Edge table:" << "\n";
vector<VOR_EDGE> ::iterator eiter = vornet->edges.begin();
while(eiter != vornet->edges.end()){
if(eiter->rad_moving_sphere > minRad){
output << eiter->from << " -> " << eiter->to << " " << eiter->rad_moving_sphere
<< " " << eiter->delta_uc_x << " " << eiter->delta_uc_y << " "
<< eiter->delta_uc_z << " " << eiter->length << "\n";
}
eiter++;
}
}
output.close();
return true;
}
/** Write the voronoi noide information within the VORONOI_NETWORK in .xyz
file format to the provided filename. Excludes any nodes with radii
less than the provided threshold. For the default 0, all nodes are included*/
bool writeToXYZ(char *filename, VORONOI_NETWORK *vornet, double minRad){
fstream output;
output.open(filename, fstream::out);
if(!output.is_open()){
cerr << "Error: Failed to open .net2 output file " << filename << "\n";
return false;
}
else{
cout << "Writing Voronoi network information to " << filename << "\n";
// Write Voronoi node information
//Compute the # of nodes to be written
int i = 0;
for (vector<VOR_NODE>::const_iterator iter = vornet->nodes.begin();
iter != vornet->nodes.end(); iter++)
if (iter->rad_stat_sphere > minRad){
i++;
}
output << i << "\n\n";
for (vector<VOR_NODE>::const_iterator iter = vornet->nodes.begin();
iter != vornet->nodes.end(); iter++)
if (iter->rad_stat_sphere > minRad)
output << "X " << iter->x << " " << iter->y << " "
<< iter->z << " " << iter->rad_stat_sphere << "\n";
}
output.close();
return true;
}
/** Write the information stored within the VORONOI_NETWORK in a .nt2
file format to the provided filename. Includes all nodes and edges. */
/* redudant
bool writeToNt2(char *filename, VORONOI_NETWORK *vornet){
return nwriteToNt2(filename, vornet, 0);
} */
/** Write the information within the provided ATOM_NETWORK in a .xyz
file format to the provided filename. */
//updated this function to permit supercell (2x2x2) and duplication of atoms on the unit cell perimeter, if desired
bool writeToXYZ(char *filename, ATOM_NETWORK *cell, bool is_supercell, bool is_duplicate_perimeter_atoms){
int num_cells = SUPERCELL_SIZE; //defined in networkio.h
if(!is_supercell) num_cells = 1;
fstream output;
output.open(filename, fstream::out);
if(!output.is_open()){
cerr << "Error: Failed to open .xyz output file " << filename << endl;
//cerr << "Exiting ..." << "\n";
//exit(1);
return false;
}
else{
cout << "Writing atom network information to " << filename << "\n";
//1) construct a new vector of atoms, which contains any supercell projections and duplicates
vector<ATOM> new_atoms;
for(int i=0; i<cell->numAtoms; i++) {
ATOM atom = cell->atoms.at(i);
Point orig_abc(atom.a_coord, atom.b_coord, atom.c_coord);
Point uc_abc = cell->shiftABCInUC(orig_abc);
//first, determine all the supercell images of this atom as required
for(int a=0; a<num_cells; a++) {
for(int b=0; b<num_cells; b++) {
for(int c=0; c<num_cells; c++) {
atom.a_coord=uc_abc[0]+a;
atom.b_coord=uc_abc[1]+b;
atom.c_coord=uc_abc[2]+c;
// Do xyz conversion later, when needed for output
new_atoms.push_back(atom);
//now we have this atom, be it the original or a supercell projection, find the duplicates
if(is_duplicate_perimeter_atoms) {
double dupe_thresh = 0.001;
if(atom.a_coord<dupe_thresh) {
ATOM dupe = atom;
dupe.a_coord = atom.a_coord+num_cells;
new_atoms.push_back(dupe);
}
if(atom.b_coord<dupe_thresh) {
ATOM dupe = atom;
dupe.b_coord = atom.b_coord+num_cells;
new_atoms.push_back(dupe);
}
if(atom.c_coord<dupe_thresh) {
ATOM dupe = atom;
dupe.c_coord = atom.c_coord+num_cells;
new_atoms.push_back(dupe);
}
if(atom.a_coord<dupe_thresh && atom.b_coord<dupe_thresh) {
ATOM dupe = atom;
dupe.a_coord = atom.a_coord+num_cells;
dupe.b_coord = atom.b_coord+num_cells;
new_atoms.push_back(dupe);
}
if(atom.a_coord<dupe_thresh && atom.c_coord<dupe_thresh) {
ATOM dupe = atom;
dupe.a_coord = atom.a_coord+num_cells;
dupe.c_coord = atom.c_coord+num_cells;
new_atoms.push_back(dupe);
}
if(atom.b_coord<dupe_thresh && atom.c_coord<dupe_thresh) {
ATOM dupe = atom;
dupe.b_coord = atom.b_coord+num_cells;
dupe.c_coord = atom.c_coord+num_cells;
new_atoms.push_back(dupe);
}
if(atom.a_coord<dupe_thresh && atom.b_coord<dupe_thresh && atom.c_coord<dupe_thresh) {
ATOM dupe = atom;
dupe.a_coord = atom.a_coord+num_cells;
dupe.b_coord = atom.b_coord+num_cells;
dupe.c_coord = atom.c_coord+num_cells;
new_atoms.push_back(dupe);
}
if(atom.a_coord>((double)(num_cells))-dupe_thresh) {
ATOM dupe = atom;
dupe.a_coord = atom.a_coord-num_cells;
new_atoms.push_back(dupe);
}
if(atom.b_coord>((double)(num_cells))-dupe_thresh) {
ATOM dupe = atom;
dupe.b_coord = atom.b_coord-num_cells;
new_atoms.push_back(dupe);
}
if(atom.c_coord>((double)(num_cells))-dupe_thresh) {
ATOM dupe = atom;
dupe.c_coord = atom.c_coord-num_cells;
new_atoms.push_back(dupe);
}
if(atom.a_coord>((double)(num_cells))-dupe_thresh && atom.b_coord>((double)(num_cells))-dupe_thresh) {
ATOM dupe = atom;
dupe.a_coord = atom.a_coord-num_cells;
dupe.b_coord = atom.b_coord-num_cells;
new_atoms.push_back(dupe);
}
if(atom.a_coord>((double)(num_cells))-dupe_thresh && atom.c_coord>((double)(num_cells))-dupe_thresh) {
ATOM dupe = atom;
dupe.a_coord = atom.a_coord-num_cells;
dupe.c_coord = atom.c_coord-num_cells;
new_atoms.push_back(dupe);
}
if(atom.b_coord>((double)(num_cells))-dupe_thresh && atom.c_coord>((double)(num_cells))-dupe_thresh) {
ATOM dupe = atom;
dupe.b_coord = atom.b_coord-num_cells;
dupe.c_coord = atom.c_coord-num_cells;
new_atoms.push_back(dupe);
}
if(atom.a_coord>((double)(num_cells))-dupe_thresh && atom.b_coord>((double)(num_cells))-dupe_thresh && atom.c_coord>((double)(num_cells))-dupe_thresh) {
ATOM dupe = atom;
dupe.a_coord = atom.a_coord-num_cells;
dupe.b_coord = atom.b_coord-num_cells;
dupe.c_coord = atom.c_coord-num_cells;
new_atoms.push_back(dupe);
}
}
}
}
}
}
//2) write atom data
output << new_atoms.size() << "\n" << "\n";
for(int i=0; i<new_atoms.size(); i++) {
Point p = cell->abc_to_xyz(new_atoms.at(i).a_coord, new_atoms.at(i).b_coord, new_atoms.at(i).c_coord);
output << new_atoms.at(i).type << " " << p[0] << " " << p[1] << " " << p[2] << "\n";
}
}
output.close();
return true;
}
/** Write the boundary of the unit cell expressed within the provided ATOM_NETWORK in a .vtk
file format to the provided filename. */
bool writeToVTK(char *filename, ATOM_NETWORK *cell){
fstream output;
output.open(filename, fstream::out);
if(!output.is_open()){
cerr << "Error: Failed to open .vtk output file " << filename << endl;
//cerr << "Exiting ..." << "\n";
//exit(1);
return false;
}
else{
cout << "Writing unit cell information to " << filename << "\n";
//For each corner in abc, get the coords in xyz
vector<Point> corners; Point p;
p = cell->abc_to_xyz(0, 0, 0); corners.push_back(p);
p = cell->abc_to_xyz(0, 0, 1); corners.push_back(p);
p = cell->abc_to_xyz(0, 1, 0); corners.push_back(p);
p = cell->abc_to_xyz(0, 1, 1); corners.push_back(p);
p = cell->abc_to_xyz(1, 0, 0); corners.push_back(p);
p = cell->abc_to_xyz(1, 0, 1); corners.push_back(p);
p = cell->abc_to_xyz(1, 1, 0); corners.push_back(p);
p = cell->abc_to_xyz(1, 1, 1); corners.push_back(p);
// Write header, information about the cell, and footer
output << "# vtk DataFile Version 2.0\nvtk format representation of unit cell boundary\nASCII\nDATASET POLYDATA\nPOINTS 8 double\n";
for(int i=0; i<8; i++) output << corners.at(i)[0] << " " << corners.at(i)[1] << " " << corners.at(i)[2] << "\n";
output << "LINES 12 36\n2 0 1\n2 0 2\n2 1 3\n2 2 3\n2 4 5\n2 4 6\n2 5 7\n2 6 7\n2 0 4\n2 1 5\n2 2 6\n2 3 7\n";
}
output.close();
return true;
}
/** Write the information within the provided ATOM_NETWORK in a .mop
file format to the provided filename. */
/** In .mop file, unit cell vectors are listed as Tv and the shape of the unit cell is kept fixed **/
bool writeToMOPAC(char *filename, ATOM_NETWORK *cell, bool is_supercell){
int num_cells = SUPERCELL_SIZE; //defined in networkio.h
if(!is_supercell) num_cells = 1;
fstream output;
output.open(filename, fstream::out);
if(!output.is_open()){
cout << "Error: Failed to open .mop output file " << filename << endl;
//cout << "Exiting ..." << "\n";
//exit(1);
return false;
}
else{
cout << "Writing atom network information to " << filename << "\n";
//Write two empty lines by default
output << "\n" << "\n";
/*
// Write information about the atoms
vector<ATOM>::iterator atomIter = cell->atoms.begin();
while(atomIter != cell->atoms.end()){
output << atomIter->type << " " << atomIter->x << " +1 "
<< atomIter->y << " +1 " << atomIter->z << " +1\n";
atomIter++;
}
*/
for(int i=0; i<cell->numAtoms; i++) {
//first, determine all the supercell images of this atom as required
for(int a=0; a<num_cells; a++) {
for(int b=0; b<num_cells; b++) {
for(int c=0; c<num_cells; c++) {
ATOM atom = cell->atoms.at(i);
atom.a_coord = trans_to_origuc(atom.a_coord)+a;
atom.b_coord = trans_to_origuc(atom.b_coord)+b;
atom.c_coord = trans_to_origuc(atom.c_coord)+c;
Point p = cell->abc_to_xyz(atom.a_coord, atom.b_coord, atom.c_coord);
output << atom.type << " " << p[0] << " +1 "
<< p[1] << " +1 " << p[2] << " +1\n";
}
}
}
}
//Write unit cell box information
output << "Tv " << cell->v_a.x*num_cells << " +1 ";
if(cell->v_a.y==0.0) { output << " 0.0 0 "; } else { output << cell->v_a.y*num_cells << " +1 ";};
if(cell->v_a.z==0.0) { output << " 0.0 0 \n"; } else { output << cell->v_a.z*num_cells << " +1 \n";};
output << "Tv ";
if(cell->v_b.x==0.0) { output << " 0.0 0 "; } else { output << cell->v_b.x*num_cells << " +1 ";};
output << cell->v_b.y*num_cells << " +1 ";
if(cell->v_b.z==0.0) { output << " 0.0 0 \n"; } else { output << cell->v_b.z*num_cells << " +1 \n";};
output << "Tv ";
if(cell->v_c.x==0.0) { output << " 0.0 0 "; } else { output << cell->v_c.x*num_cells << " +1 ";};
if(cell->v_c.y==0.0) { output << " 0.0 0 "; } else { output << cell->v_c.y*num_cells << " +1 ";};
output << cell->v_c.z*num_cells << " +1 \n\n";
}
output.close();
return true;
}
/** Change the type of the atom to its appropriate form. Used when
reading .cuc files. */
void changeAtomType(ATOM *atom){
switch(atom->type[0]){
case 'O': case 'o':
atom->type = "O";
break;
case 'T': case 't':
atom->type = "Si";
break;
case 'A': case 'a':
atom->type = "Si";
break;
case 'H': case 'h':
atom->type = "H";
break;
case 'S': case 's':
if(tolower(atom->type[1]) == 'i')
atom->type = "Si";
else
atom->type = "S";
break;
default:
cerr<< "Error: Atom name not recognized " << atom->type << "\n";
// << "Exiting..." << "\n";
// exit(1);
break;
}
}
/** Strip atom names from additional indexes following atom string */
void stripAtomNames(ATOM_NETWORK *cell)
{
for(unsigned int na = 0; na < cell->atoms.size(); na++)
cell->atoms[na].type = stripAtomName(cell->atoms[na].type);
// for (vector<ATOM>::const_iterator it=cell->atoms.begin(); it!=cell->atoms.end(); ++it){
// it->type = stripAtomName(it->type);
// cout << stripAtomName(it->type) << "\n";
// }
}
| 37.820484 | 295 | 0.588227 | Luthaf |
297c6dcb64155ce6bd1968f192ae11d61e356c3d | 9,998 | cpp | C++ | rsa.cpp | ex0ample/cryptopp | 9ea66ce4d97d59d61e49c93f5af191107ebd1925 | [
"BSL-1.0"
] | 1 | 2020-03-10T06:53:50.000Z | 2020-03-10T06:53:50.000Z | rsa.cpp | ex0ample/cryptopp | 9ea66ce4d97d59d61e49c93f5af191107ebd1925 | [
"BSL-1.0"
] | null | null | null | rsa.cpp | ex0ample/cryptopp | 9ea66ce4d97d59d61e49c93f5af191107ebd1925 | [
"BSL-1.0"
] | null | null | null | // rsa.cpp - originally written and placed in the public domain by Wei Dai
#include "pch.h"
#include "rsa.h"
#include "asn.h"
#include "sha.h"
#include "oids.h"
#include "modarith.h"
#include "nbtheory.h"
#include "algparam.h"
#include "fips140.h"
#include "pkcspad.h"
#if defined(CRYPTOPP_DEBUG) && !defined(CRYPTOPP_DOXYGEN_PROCESSING) && !defined(CRYPTOPP_IS_DLL)
#include "sha3.h"
#include "pssr.h"
NAMESPACE_BEGIN(CryptoPP)
void RSA_TestInstantiations()
{
RSASS<PKCS1v15, SHA1>::Verifier x1(1, 1);
RSASS<PKCS1v15, SHA1>::Signer x2(NullRNG(), 1);
RSASS<PKCS1v15, SHA1>::Verifier x3(x2);
RSASS<PKCS1v15, SHA1>::Verifier x4(x2.GetKey());
RSASS<PSS, SHA1>::Verifier x5(x3);
#ifndef __MWERKS__
RSASS<PSSR, SHA1>::Signer x6 = x2;
x3 = x2;
x6 = x2;
#endif
RSAES<PKCS1v15>::Encryptor x7(x2);
#ifndef __GNUC__
RSAES<PKCS1v15>::Encryptor x8(x3);
#endif
RSAES<OAEP<SHA1> >::Encryptor x9(x2);
x4 = x2.GetKey();
RSASS<PKCS1v15, SHA3_256>::Verifier x10(1, 1);
RSASS<PKCS1v15, SHA3_256>::Signer x11(NullRNG(), 1);
RSASS<PKCS1v15, SHA3_256>::Verifier x12(x11);
RSASS<PKCS1v15, SHA3_256>::Verifier x13(x11.GetKey());
}
NAMESPACE_END
#endif
#ifndef CRYPTOPP_IMPORTS
NAMESPACE_BEGIN(CryptoPP)
OID RSAFunction::GetAlgorithmID() const
{
return ASN1::rsaEncryption();
}
void RSAFunction::BERDecodePublicKey(BufferedTransformation &bt, bool, size_t)
{
BERSequenceDecoder seq(bt);
m_n.BERDecode(seq);
m_e.BERDecode(seq);
seq.MessageEnd();
}
void RSAFunction::DEREncodePublicKey(BufferedTransformation &bt) const
{
DERSequenceEncoder seq(bt);
m_n.DEREncode(seq);
m_e.DEREncode(seq);
seq.MessageEnd();
}
Integer RSAFunction::ApplyFunction(const Integer &x) const
{
DoQuickSanityCheck();
return a_exp_b_mod_c(x, m_e, m_n);
}
bool RSAFunction::Validate(RandomNumberGenerator& rng, unsigned int level) const
{
CRYPTOPP_UNUSED(rng), CRYPTOPP_UNUSED(level);
bool pass = true;
pass = pass && m_n > Integer::One() && m_n.IsOdd();
CRYPTOPP_ASSERT(pass);
pass = pass && m_e > Integer::One() && m_e.IsOdd() && m_e < m_n;
CRYPTOPP_ASSERT(pass);
return pass;
}
bool RSAFunction::GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const
{
return GetValueHelper(this, name, valueType, pValue).Assignable()
CRYPTOPP_GET_FUNCTION_ENTRY(Modulus)
CRYPTOPP_GET_FUNCTION_ENTRY(PublicExponent)
;
}
void RSAFunction::AssignFrom(const NameValuePairs &source)
{
AssignFromHelper(this, source)
CRYPTOPP_SET_FUNCTION_ENTRY(Modulus)
CRYPTOPP_SET_FUNCTION_ENTRY(PublicExponent)
;
}
// *****************************************************************************
class RSAPrimeSelector : public PrimeSelector
{
public:
RSAPrimeSelector(const Integer &e) : m_e(e) {}
bool IsAcceptable(const Integer &candidate) const {return RelativelyPrime(m_e, candidate-Integer::One());}
Integer m_e;
};
void InvertibleRSAFunction::GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &alg)
{
int modulusSize = 2048;
alg.GetIntValue(Name::ModulusSize(), modulusSize) || alg.GetIntValue(Name::KeySize(), modulusSize);
CRYPTOPP_ASSERT(modulusSize >= 16);
if (modulusSize < 16)
throw InvalidArgument("InvertibleRSAFunction: specified modulus size is too small");
m_e = alg.GetValueWithDefault(Name::PublicExponent(), Integer(17));
CRYPTOPP_ASSERT(m_e >= 3); CRYPTOPP_ASSERT(!m_e.IsEven());
if (m_e < 3 || m_e.IsEven())
throw InvalidArgument("InvertibleRSAFunction: invalid public exponent");
RSAPrimeSelector selector(m_e);
AlgorithmParameters primeParam = MakeParametersForTwoPrimesOfEqualSize(modulusSize)
(Name::PointerToPrimeSelector(), selector.GetSelectorPointer());
m_p.GenerateRandom(rng, primeParam);
m_q.GenerateRandom(rng, primeParam);
m_d = m_e.InverseMod(LCM(m_p-1, m_q-1));
CRYPTOPP_ASSERT(m_d.IsPositive());
m_dp = m_d % (m_p-1);
m_dq = m_d % (m_q-1);
m_n = m_p * m_q;
m_u = m_q.InverseMod(m_p);
if (FIPS_140_2_ComplianceEnabled())
{
RSASS<PKCS1v15, SHA1>::Signer signer(*this);
RSASS<PKCS1v15, SHA1>::Verifier verifier(signer);
SignaturePairwiseConsistencyTest_FIPS_140_Only(signer, verifier);
RSAES<OAEP<SHA1> >::Decryptor decryptor(*this);
RSAES<OAEP<SHA1> >::Encryptor encryptor(decryptor);
EncryptionPairwiseConsistencyTest_FIPS_140_Only(encryptor, decryptor);
}
}
void InvertibleRSAFunction::Initialize(RandomNumberGenerator &rng, unsigned int keybits, const Integer &e)
{
GenerateRandom(rng, MakeParameters(Name::ModulusSize(), (int)keybits)(Name::PublicExponent(), e+e.IsEven()));
}
void InvertibleRSAFunction::Initialize(const Integer &n, const Integer &e, const Integer &d)
{
if (n.IsEven() || e.IsEven() || d.IsEven())
throw InvalidArgument("InvertibleRSAFunction: input is not a valid RSA private key");
m_n = n;
m_e = e;
m_d = d;
Integer r = --(d*e);
unsigned int s = 0;
while (r.IsEven())
{
r >>= 1;
s++;
}
ModularArithmetic modn(n);
for (Integer i = 2; ; ++i)
{
Integer a = modn.Exponentiate(i, r);
if (a == 1)
continue;
Integer b;
unsigned int j = 0;
while (a != n-1)
{
b = modn.Square(a);
if (b == 1)
{
m_p = GCD(a-1, n);
m_q = n/m_p;
m_dp = m_d % (m_p-1);
m_dq = m_d % (m_q-1);
m_u = m_q.InverseMod(m_p);
return;
}
if (++j == s)
throw InvalidArgument("InvertibleRSAFunction: input is not a valid RSA private key");
a = b;
}
}
}
void InvertibleRSAFunction::BERDecodePrivateKey(BufferedTransformation &bt, bool, size_t)
{
BERSequenceDecoder privateKey(bt);
word32 version;
BERDecodeUnsigned<word32>(privateKey, version, INTEGER, 0, 0); // check version
m_n.BERDecode(privateKey);
m_e.BERDecode(privateKey);
m_d.BERDecode(privateKey);
m_p.BERDecode(privateKey);
m_q.BERDecode(privateKey);
m_dp.BERDecode(privateKey);
m_dq.BERDecode(privateKey);
m_u.BERDecode(privateKey);
privateKey.MessageEnd();
}
void InvertibleRSAFunction::DEREncodePrivateKey(BufferedTransformation &bt) const
{
DERSequenceEncoder privateKey(bt);
DEREncodeUnsigned<word32>(privateKey, 0); // version
m_n.DEREncode(privateKey);
m_e.DEREncode(privateKey);
m_d.DEREncode(privateKey);
m_p.DEREncode(privateKey);
m_q.DEREncode(privateKey);
m_dp.DEREncode(privateKey);
m_dq.DEREncode(privateKey);
m_u.DEREncode(privateKey);
privateKey.MessageEnd();
}
Integer InvertibleRSAFunction::CalculateInverse(RandomNumberGenerator &rng, const Integer &x) const
{
DoQuickSanityCheck();
ModularArithmetic modn(m_n);
Integer r, rInv;
do { // do this in a loop for people using small numbers for testing
r.Randomize(rng, Integer::One(), m_n - Integer::One());
rInv = modn.MultiplicativeInverse(r);
} while (rInv.IsZero());
Integer re = modn.Exponentiate(r, m_e);
re = modn.Multiply(re, x); // blind
// here we follow the notation of PKCS #1 and let u=q inverse mod p
// but in ModRoot, u=p inverse mod q, so we reverse the order of p and q
Integer y = ModularRoot(re, m_dq, m_dp, m_q, m_p, m_u);
y = modn.Multiply(y, rInv); // unblind
if (modn.Exponentiate(y, m_e) != x) // check
throw Exception(Exception::OTHER_ERROR, "InvertibleRSAFunction: computational error during private key operation");
return y;
}
bool InvertibleRSAFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const
{
bool pass = RSAFunction::Validate(rng, level);
CRYPTOPP_ASSERT(pass);
pass = pass && m_p > Integer::One() && m_p.IsOdd() && m_p < m_n;
CRYPTOPP_ASSERT(pass);
pass = pass && m_q > Integer::One() && m_q.IsOdd() && m_q < m_n;
CRYPTOPP_ASSERT(pass);
pass = pass && m_d > Integer::One() && m_d.IsOdd() && m_d < m_n;
CRYPTOPP_ASSERT(pass);
pass = pass && m_dp > Integer::One() && m_dp.IsOdd() && m_dp < m_p;
CRYPTOPP_ASSERT(pass);
pass = pass && m_dq > Integer::One() && m_dq.IsOdd() && m_dq < m_q;
CRYPTOPP_ASSERT(pass);
pass = pass && m_u.IsPositive() && m_u < m_p;
CRYPTOPP_ASSERT(pass);
if (level >= 1)
{
pass = pass && m_p * m_q == m_n;
CRYPTOPP_ASSERT(pass);
pass = pass && m_e*m_d % LCM(m_p-1, m_q-1) == 1;
CRYPTOPP_ASSERT(pass);
pass = pass && m_dp == m_d%(m_p-1) && m_dq == m_d%(m_q-1);
CRYPTOPP_ASSERT(pass);
pass = pass && m_u * m_q % m_p == 1;
CRYPTOPP_ASSERT(pass);
}
if (level >= 2)
{
pass = pass && VerifyPrime(rng, m_p, level-2) && VerifyPrime(rng, m_q, level-2);
CRYPTOPP_ASSERT(pass);
}
return pass;
}
bool InvertibleRSAFunction::GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const
{
return GetValueHelper<RSAFunction>(this, name, valueType, pValue).Assignable()
CRYPTOPP_GET_FUNCTION_ENTRY(Prime1)
CRYPTOPP_GET_FUNCTION_ENTRY(Prime2)
CRYPTOPP_GET_FUNCTION_ENTRY(PrivateExponent)
CRYPTOPP_GET_FUNCTION_ENTRY(ModPrime1PrivateExponent)
CRYPTOPP_GET_FUNCTION_ENTRY(ModPrime2PrivateExponent)
CRYPTOPP_GET_FUNCTION_ENTRY(MultiplicativeInverseOfPrime2ModPrime1)
;
}
void InvertibleRSAFunction::AssignFrom(const NameValuePairs &source)
{
AssignFromHelper<RSAFunction>(this, source)
CRYPTOPP_SET_FUNCTION_ENTRY(Prime1)
CRYPTOPP_SET_FUNCTION_ENTRY(Prime2)
CRYPTOPP_SET_FUNCTION_ENTRY(PrivateExponent)
CRYPTOPP_SET_FUNCTION_ENTRY(ModPrime1PrivateExponent)
CRYPTOPP_SET_FUNCTION_ENTRY(ModPrime2PrivateExponent)
CRYPTOPP_SET_FUNCTION_ENTRY(MultiplicativeInverseOfPrime2ModPrime1)
;
}
// *****************************************************************************
Integer RSAFunction_ISO::ApplyFunction(const Integer &x) const
{
Integer t = RSAFunction::ApplyFunction(x);
return t % 16 == 12 ? t : m_n - t;
}
Integer InvertibleRSAFunction_ISO::CalculateInverse(RandomNumberGenerator &rng, const Integer &x) const
{
Integer t = InvertibleRSAFunction::CalculateInverse(rng, x);
return STDMIN(t, m_n-t);
}
NAMESPACE_END
#endif
| 30.205438 | 118 | 0.691138 | ex0ample |
2981fde212706d40f34805e7f73e99d810971414 | 2,617 | cpp | C++ | tests/experimental/test_ExperimentalUserConstraint.cpp | quadric-io/crave | 8096d8b151cbe0d2ba437657f42d8bb0e05f5436 | [
"MIT"
] | 32 | 2015-05-11T02:38:40.000Z | 2022-02-23T07:31:26.000Z | tests/experimental/test_ExperimentalUserConstraint.cpp | quadric-io/crave | 8096d8b151cbe0d2ba437657f42d8bb0e05f5436 | [
"MIT"
] | 10 | 2018-06-08T14:44:58.000Z | 2021-08-19T16:07:21.000Z | tests/experimental/test_ExperimentalUserConstraint.cpp | quadric-io/crave | 8096d8b151cbe0d2ba437657f42d8bb0e05f5436 | [
"MIT"
] | 8 | 2019-05-29T21:40:31.000Z | 2021-12-01T09:31:15.000Z | #include <boost/test/unit_test.hpp>
#include <crave/ir/UserConstraint.hpp>
#include <crave/ir/UserExpression.hpp>
#include <crave/utils/Evaluator.hpp>
#include <crave/ir/visitor/ComplexityEstimationVisitor.hpp>
// using namespace std;
using namespace crave;
BOOST_FIXTURE_TEST_SUITE(UserConstraint, Context_Fixture)
BOOST_AUTO_TEST_CASE(constraint_partitioning) {
crv_variable<unsigned> a, b, c, d, e;
ConstraintPartitioner cp;
ConstraintManager cm1, cm2;
Context ctx(variable_container());
cm1.makeConstraint(a() > b(), &ctx);
cm1.makeConstraint(c() > d(), &ctx);
cm1.makeConstraint(e() > 1, &ctx);
cm2.makeConstraint(a() != e(), &ctx);
cp.reset();
cp.mergeConstraints(cm1);
cp.partition();
BOOST_REQUIRE_EQUAL(cp.getPartitions().size(), 3);
cp.reset();
cp.mergeConstraints(cm1);
cp.mergeConstraints(cm2);
cp.partition();
BOOST_REQUIRE_EQUAL(cp.getPartitions().size(), 2);
}
BOOST_AUTO_TEST_CASE(constraint_expression_mixing) {
crv_variable<unsigned> x, y, z, t;
expression e1 = make_expression(x() + y());
expression e2 = make_expression(z() + t() > 10);
Evaluator evaluator;
evaluator.assign(x(), 8);
evaluator.assign(y(), 1);
evaluator.assign(z(), 8);
evaluator.assign(t(), 3);
BOOST_REQUIRE(evaluator.evaluate((x() > z()) && (e1 <= 10) && e2));
BOOST_REQUIRE(!evaluator.result<bool>());
evaluator.assign(x(), 9);
BOOST_REQUIRE(evaluator.evaluate((x() > z()) && (e1 + 1 <= 11) && e2));
BOOST_REQUIRE(evaluator.result<bool>());
BOOST_REQUIRE(evaluator.evaluate(e1 * e1));
BOOST_REQUIRE_EQUAL(evaluator.result<unsigned>(), 100);
}
BOOST_AUTO_TEST_CASE(single_variable_constraint) {
crv_variable<unsigned> a, b, c, d;
ConstraintPartitioner cp;
ConstraintManager cm;
Context ctx(variable_container());
cm.makeConstraint(a() > 1, &ctx);
cm.makeConstraint(a() < 2, &ctx);
cm.makeConstraint((1 < b()) || (b() < 10), &ctx);
cm.makeConstraint(c() + 5 > c() + 2 * c(), &ctx);
cm.makeConstraint(a() + b() + c() > 0, &ctx);
cm.makeConstraint(c() < d(), &ctx);
cp.reset();
cp.mergeConstraints(cm);
cp.partition();
BOOST_REQUIRE_EQUAL(cp.getPartitions().size(), 1);
ConstraintPartition const& part = cp.getPartitions().at(0);
BOOST_REQUIRE_EQUAL(part.singleVariableConstraintMap().size(), 3);
BOOST_REQUIRE_EQUAL(part.singleVariableConstraintMap().at(a().id()).size(), 2);
BOOST_REQUIRE_EQUAL(part.singleVariableConstraintMap().at(b().id()).size(), 1);
BOOST_REQUIRE_EQUAL(part.singleVariableConstraintMap().at(c().id()).size(), 1);
}
BOOST_AUTO_TEST_SUITE_END() // Syntax
// vim: ft=cpp:ts=2:sw=2:expandtab
| 31.53012 | 81 | 0.690485 | quadric-io |
2984d51cde646c84acf0c927b0996cddf100c31e | 2,669 | cc | C++ | src/pygmm.cc | zxytim/fast-gmm | 5b6940d62c950889d51d5a3dfc99907e3b631958 | [
"MIT"
] | 20 | 2015-10-27T10:41:32.000Z | 2020-12-23T06:10:36.000Z | src/pygmm.cc | H2020-InFuse/fast-gmm | e88b58d0cb3c9cf1579e6e7c6523a4f10d7e904a | [
"MIT"
] | 3 | 2017-03-06T07:51:38.000Z | 2018-08-16T08:36:34.000Z | src/pygmm.cc | H2020-InFuse/fast-gmm | e88b58d0cb3c9cf1579e6e7c6523a4f10d7e904a | [
"MIT"
] | 6 | 2017-01-26T12:57:01.000Z | 2019-05-18T06:55:16.000Z | /*
* $File: pygmm.cc
* $Date: Wed Dec 11 18:50:31 2013 +0800
* $Author: Xinyu Zhou <zxytim[at]gmail[dot]com>
*/
#include "pygmm.hh"
#include "gmm.hh"
#include <fstream>
using namespace std;
typedef vector<vector<real_t>> DenseDataset;
void conv_double_pp_to_vv(double **Xp, DenseDataset &X, int nr_instance, int nr_dim) {
X.resize(nr_instance);
for (auto &x: X)
x.resize(nr_dim);
for (int i = 0; i < nr_instance; i ++)
for (int j = 0; j < nr_dim; j ++)
X[i][j] = Xp[i][j];
}
void conv_double_p_to_v(double *x_in, vector<real_t> &x, int nr_dim) {
x.resize(nr_dim);
for (int i = 0; i < nr_dim; i ++)
x[i] = x_in[i];
}
void print_param(Parameter *param) {
printf("nr_instance : %d\n", param->nr_instance);
printf("nr_dim : %d\n", param->nr_dim);
printf("nr_mixture : %d\n", param->nr_mixture);
printf("min_covar : %f\n", param->min_covar);
printf("threshold : %f\n", param->threshold);
printf("nr_iteration : %d\n", param->nr_iteration);
printf("init_with_kmeans: %d\n", param->init_with_kmeans);
printf("concurrency : %d\n", param->concurrency);
printf("verbosity : %d\n", param->verbosity);
}
void print_X(double **X) {
printf("X: %p\n", X);
printf("X: %p\n", X[0]);
printf("X: %f\n", X[0][0]);
}
GMM *new_gmm(int nr_mixture, int covariance_type) {
return new GMM(nr_mixture, covariance_type);
}
GMM *load(const char *model_file) {
return new GMM(model_file);
}
void dump(GMM *gmm, const char *model_file) {
ofstream fout(model_file);
gmm->dump(fout);
}
void train_model(GMM *gmm, double **X_in, Parameter *param) {
print_param(param);
GMMTrainerBaseline trainer(param->nr_iteration, param->min_covar, param->init_with_kmeans, param->concurrency, param->verbosity);
gmm->trainer = &trainer;
DenseDataset X;
conv_double_pp_to_vv(X_in, X, param->nr_instance, param->nr_dim);
gmm->fit(X);
}
double score_all(GMM *gmm, double **X_in, int nr_instance, int nr_dim, int concurrency) {
DenseDataset X;
conv_double_pp_to_vv(X_in, X, nr_instance, nr_dim);
return gmm->log_probability_of_fast_exp_threaded(X, concurrency);
}
void score_batch(GMM *gmm, double **X_in, double *prob_out, int nr_instance, int nr_dim, int concurrency) {
DenseDataset X;
conv_double_pp_to_vv(X_in, X, nr_instance, nr_dim);
std::vector<real_t> prob;
gmm->log_probability_of_fast_exp_threaded(X, prob, concurrency);
for (size_t i = 0; i < prob.size(); i ++)
prob_out[i] = prob[i];
}
double score_instance(GMM *gmm, double *x_in, int nr_dim) {
vector<real_t> x;
conv_double_p_to_v(x_in, x, nr_dim);
return gmm->log_probability_of_fast_exp(x);
}
/**
* vim: syntax=cpp11 foldmethod=marker
*/
| 27.515464 | 130 | 0.681529 | zxytim |
2985674b4ce02f5cef60c46ba37c6b8b0fca82b8 | 19,310 | cc | C++ | gearmand/gearmand.cc | alionurdemetoglu/gearmand | dd9ac59a730f816e0dc5f27f98fdc06a08cc4c22 | [
"BSD-3-Clause"
] | 712 | 2016-07-02T03:32:22.000Z | 2022-03-23T14:23:02.000Z | gearmand/gearmand.cc | alionurdemetoglu/gearmand | dd9ac59a730f816e0dc5f27f98fdc06a08cc4c22 | [
"BSD-3-Clause"
] | 294 | 2016-07-03T16:17:41.000Z | 2022-03-30T04:37:49.000Z | gearmand/gearmand.cc | alionurdemetoglu/gearmand | dd9ac59a730f816e0dc5f27f98fdc06a08cc4c22 | [
"BSD-3-Clause"
] | 163 | 2016-07-08T10:03:38.000Z | 2022-01-21T05:03:48.000Z | /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
*
* Gearmand client and server library.
*
* Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/
* Copyright (C) 2008 Brian Aker, Eric Day
* 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.
*
* * The names of its contributors may not 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 "gear_config.h"
#include "configmake.h"
#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fcntl.h>
#include <fstream>
#include <pwd.h>
#include <signal.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <syslog.h>
#include <unistd.h>
#include <grp.h>
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
#include "libgearman-server/gearmand.h"
#include "libgearman-server/plugins.h"
#include "libgearman-server/queue.hpp"
#define GEARMAND_LOG_REOPEN_TIME 60
#include "util/daemon.hpp"
#include "util/pidfile.hpp"
#include <boost/program_options.hpp>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/program_options/variables_map.hpp>
#include <boost/token_functions.hpp>
#include <boost/tokenizer.hpp>
#include <iostream>
#include "libtest/cpu.hpp"
#include "gearmand/error.hpp"
#include "gearmand/log.hpp"
#include "libgearman/backtrace.hpp"
using namespace datadifferential;
using namespace gearmand;
static bool _set_fdlimit(rlim_t fds);
static bool _switch_user(const char *user);
extern "C" {
static bool _set_signals(bool core_dump= false);
}
static void _log(const char *line, gearmand_verbose_t verbose, void *context);
int main(int argc, char *argv[])
{
gearmand::error::init(argv[0]);
int backlog;
rlim_t fds= 0;
uint32_t job_retries;
uint32_t worker_wakeup;
std::string host;
std::string user;
std::string log_file;
std::string pid_file;
std::string protocol;
std::string queue_type;
std::string job_handle_prefix;
std::string verbose_string;
std::string config_file;
uint32_t threads;
bool opt_exceptions;
bool opt_round_robin;
bool opt_daemon;
bool opt_check_args;
bool opt_syslog;
bool opt_coredump;
uint32_t hashtable_buckets;
bool opt_keepalive;
int opt_keepalive_idle;
int opt_keepalive_interval;
int opt_keepalive_count;
boost::program_options::options_description general("General options");
general.add_options()
("backlog,b", boost::program_options::value(&backlog)->default_value(32),
"Number of backlog connections for listen.")
("daemon,d", boost::program_options::bool_switch(&opt_daemon)->default_value(false),
"Daemon, detach and run in the background.")
("exceptions", boost::program_options::bool_switch(&opt_exceptions)->default_value(false),
"Enable protocol exceptions by default.")
("file-descriptors,f", boost::program_options::value(&fds),
"Number of file descriptors to allow for the process (total connections will be slightly less). Default is max allowed for user.")
("help,h", "Print this help menu.")
("job-retries,j", boost::program_options::value(&job_retries)->default_value(0),
"Number of attempts to run the job before the job server removes it. This is helpful to ensure a bad job does not crash all available workers. Default is no limit.")
("job-handle-prefix", boost::program_options::value(&job_handle_prefix),
"Prefix used to generate a job handle string. If not provided, the default \"H:<host_name>\" is used.")
("hashtable-buckets", boost::program_options::value(&hashtable_buckets)->default_value(GEARMAND_DEFAULT_HASH_SIZE),
"Number of buckets in the internal job hash tables. The default of 991 works well for about three million jobs in queue. If the number of jobs in the queue at any time will exceed three million, use proportionally larger values (991 * # of jobs / 3M). For example, to accommodate 2^32 jobs, use 1733003. This will consume ~26MB of extra memory. Gearmand cannot support more than 2^32 jobs in queue at this time.")
("keepalive", boost::program_options::bool_switch(&opt_keepalive)->default_value(false),
"Enable keepalive on sockets.")
("keepalive-idle", boost::program_options::value(&opt_keepalive_idle)->default_value(-1),
"If keepalive is enabled, set the value for TCP_KEEPIDLE for systems that support it. A value of -1 means that either the system does not support it or an error occurred when trying to retrieve the default value.")
("keepalive-interval", boost::program_options::value(&opt_keepalive_interval)->default_value(-1),
"If keepalive is enabled, set the value for TCP_KEEPINTVL for systems that support it. A value of -1 means that either the system does not support it or an error occurred when trying to retrieve the default value.")
("keepalive-count", boost::program_options::value(&opt_keepalive_count)->default_value(-1),
"If keepalive is enabled, set the value for TCP_KEEPCNT for systems that support it. A value of -1 means that either the system does not support it or an error occurred when trying to retrieve the default value.")
("log-file,l", boost::program_options::value(&log_file)->default_value(LOCALSTATEDIR"/log/gearmand.log"),
"Log file to write errors and information to. If the log-file parameter is specified as 'stderr', then output will go to stderr. If 'none', then no logfile will be generated.")
("listen,L", boost::program_options::value(&host),
"Address the server should listen on. Default is INADDR_ANY.")
("pid-file,P", boost::program_options::value(&pid_file)->default_value(GEARMAND_PID),
"File to write process ID out to.")
("protocol,r", boost::program_options::value(&protocol),
"Load protocol module.")
("round-robin,R", boost::program_options::bool_switch(&opt_round_robin)->default_value(false),
"Assign work in round-robin order per worker connection. The default is to assign work in the order of functions added by the worker.")
("queue-type,q", boost::program_options::value(&queue_type)->default_value("builtin"),
"Persistent queue type to use.")
("config-file", boost::program_options::value(&config_file)->default_value(GEARMAND_CONFIG),
"Can be specified with '@name', too")
("syslog", boost::program_options::bool_switch(&opt_syslog)->default_value(false),
"Use syslog.")
("coredump", boost::program_options::bool_switch(&opt_coredump)->default_value(false),
"Whether to create a core dump for uncaught signals.")
("threads,t", boost::program_options::value(&threads)->default_value(4),
"Number of I/O threads to use, 0 means that gearmand will try to guess the maximum number it can use. Default=4.")
("user,u", boost::program_options::value(&user),
"Switch to given user after startup.")
("verbose", boost::program_options::value(&verbose_string)->default_value("ERROR"),
"Set verbose level (FATAL, ALERT, CRITICAL, ERROR, WARNING, NOTICE, INFO, DEBUG).")
("version,V", "Display the version of gearmand and exit.")
("worker-wakeup,w", boost::program_options::value(&worker_wakeup)->default_value(0),
"Number of workers to wakeup for each job received. The default is to wakeup all available workers.")
;
boost::program_options::options_description all("Allowed options");
all.add(general);
gearmand::protocol::HTTP http;
all.add(http.command_line_options());
gearmand::protocol::Gear gear;
all.add(gear.command_line_options());
gearmand::plugins::initialize(all);
boost::program_options::positional_options_description positional;
positional.add("provided", -1);
// Now insert all options that we want to make visible to the user
boost::program_options::options_description visible("Allowed options");
visible.add(all);
boost::program_options::options_description hidden("Hidden options");
hidden.add_options()
("check-args", boost::program_options::bool_switch(&opt_check_args)->default_value(false),
"Check command line and configuration file arguments and then exit.");
all.add(hidden);
boost::program_options::variables_map vm;
try {
// Disable allow_guessing
int style= boost::program_options::command_line_style::default_style ^ boost::program_options::command_line_style::allow_guessing;
boost::program_options::parsed_options parsed= boost::program_options::command_line_parser(argc, argv)
.options(all)
.positional(positional)
.style(style)
.run();
store(parsed, vm);
notify(vm);
if (config_file.empty() == false)
{
// Load the file and tokenize it
std::ifstream ifs(config_file.c_str());
if (ifs)
{
// Read the whole file into a string
std::stringstream ss;
ss << ifs.rdbuf();
// Split the file content
boost::char_separator<char> sep(" \n\r");
std::string sstr= ss.str();
boost::tokenizer<boost::char_separator<char> > tok(sstr, sep);
std::vector<std::string> args;
std::copy(tok.begin(), tok.end(), back_inserter(args));
#if defined(DEBUG) && DEBUG
for (std::vector<std::string>::iterator iter= args.begin();
iter != args.end();
++iter)
{
std::cerr << *iter << std::endl;
}
#endif
// Parse the file and store the options
store(boost::program_options::command_line_parser(args).options(visible).run(), vm);
}
else if (config_file.compare(GEARMAND_CONFIG))
{
error::message("Could not open configuration file.");
return EXIT_FAILURE;
}
}
notify(vm);
}
catch(boost::program_options::validation_error &e)
{
error::message(e.what());
return EXIT_FAILURE;
}
catch(std::exception &e)
{
if (e.what() and strncmp("-v", e.what(), 2) == 0)
{
error::message("Option -v has been deprecated, please use --verbose");
}
else
{
error::message(e.what());
}
return EXIT_FAILURE;
}
gearmand_verbose_t verbose= GEARMAND_VERBOSE_ERROR;
if (gearmand_verbose_check(verbose_string.c_str(), verbose) == false)
{
error::message("Invalid value for --verbose supplied");
return EXIT_FAILURE;
}
if (hashtable_buckets <= 0)
{
error::message("hashtable-buckets has to be greater than 0");
return EXIT_FAILURE;
}
if (opt_check_args)
{
return EXIT_SUCCESS;
}
if (vm.count("help"))
{
std::cout << visible << std::endl;
return EXIT_SUCCESS;
}
if (vm.count("version"))
{
std::cout << std::endl << "gearmand " << gearmand_version() << " - " << gearmand_bugreport() << std::endl;
return EXIT_SUCCESS;
}
if (fds > 0 and _set_fdlimit(fds))
{
return EXIT_FAILURE;
}
if (not user.empty() and _switch_user(user.c_str()))
{
return EXIT_FAILURE;
}
if (opt_daemon)
{
util::daemonize(false, true);
}
if (_set_signals(opt_coredump))
{
return EXIT_FAILURE;
}
util::Pidfile _pid_file(pid_file);
if (_pid_file.create() == false and pid_file.compare(GEARMAND_PID))
{
error::perror(_pid_file.error_message().c_str());
return EXIT_FAILURE;
}
gearmand::gearmand_log_info_st log_info(log_file, opt_syslog);
if (log_info.initialized() == false)
{
return EXIT_FAILURE;
}
if (threads == 0)
{
uint32_t number_of_threads= libtest::number_of_cpus();
if (number_of_threads > 4)
{
threads= number_of_threads;
}
}
gearmand_config_st *gearmand_config= gearmand_config_create();
if (gearmand_config == NULL)
{
return EXIT_FAILURE;
}
gearmand_config_sockopt_keepalive(gearmand_config, opt_keepalive);
gearmand_config_sockopt_keepalive_count(gearmand_config, opt_keepalive_count);
gearmand_config_sockopt_keepalive_idle(gearmand_config, opt_keepalive_idle);
gearmand_config_sockopt_keepalive_interval(gearmand_config, opt_keepalive_interval);
gearmand_st *_gearmand= gearmand_create(gearmand_config,
host.empty() ? NULL : host.c_str(),
threads, backlog,
static_cast<uint8_t>(job_retries),
job_handle_prefix.empty() ? NULL : job_handle_prefix.c_str(),
static_cast<uint8_t>(worker_wakeup),
_log, &log_info, verbose,
opt_round_robin, opt_exceptions,
hashtable_buckets);
if (_gearmand == NULL)
{
error::message("Could not create gearmand library instance.");
return EXIT_FAILURE;
}
gearmand_config_free(gearmand_config);
assert(queue_type.size());
if (queue_type.empty() == false)
{
gearmand_error_t rc;
if ((rc= gearmand::queue::initialize(_gearmand, queue_type.c_str())) != GEARMAND_SUCCESS)
{
error::message("Error while initializing the queue", queue_type.c_str());
gearmand_free(_gearmand);
return EXIT_FAILURE;
}
}
if (gear.start(_gearmand) != GEARMAND_SUCCESS)
{
error::message("Error while enabling Gear protocol module");
gearmand_free(_gearmand);
return EXIT_FAILURE;
}
if (protocol.compare("http") == 0)
{
if (http.start(_gearmand) != GEARMAND_SUCCESS)
{
error::message("Error while enabling protocol module", protocol.c_str());
gearmand_free(_gearmand);
return EXIT_FAILURE;
}
}
else if (protocol.empty() == false)
{
error::message("Unknown protocol module", protocol.c_str());
gearmand_free(_gearmand);
return EXIT_FAILURE;
}
if (opt_daemon)
{
if (util::daemon_is_ready(true) == false)
{
return EXIT_FAILURE;
}
}
gearmand_error_t ret= gearmand_run(_gearmand);
gearmand_free(_gearmand);
_gearmand= NULL;
return (ret == GEARMAND_SUCCESS || ret == GEARMAND_SHUTDOWN) ? 0 : 1;
}
static bool _set_fdlimit(rlim_t fds)
{
struct rlimit rl;
if (getrlimit(RLIMIT_NOFILE, &rl) == -1)
{
error::perror("Could not get file descriptor limit");
return true;
}
rl.rlim_cur= fds;
if (rl.rlim_max < rl.rlim_cur)
{
rl.rlim_max= rl.rlim_cur;
}
if (setrlimit(RLIMIT_NOFILE, &rl) == -1)
{
error::perror("Failed to set limit for the number of file "
"descriptors. Try running as root or giving a "
"smaller value to -f.");
return true;
}
return false;
}
static bool _switch_user(const char *user)
{
if (getuid() == 0 or geteuid() == 0)
{
struct passwd *pw= getpwnam(user);
if (not pw)
{
error::message("Could not find user", user);
return EXIT_FAILURE;
}
if (setgroups(0, NULL) == -1 ||
setgid(pw->pw_gid) == -1 ||
setuid(pw->pw_uid) == -1)
{
error::message("Could not switch to user", user);
return EXIT_FAILURE;
}
}
else
{
error::message("Must be root to switch users.");
return true;
}
return false;
}
extern "C" void _shutdown_handler(int signal_, siginfo_t*, void*)
{
if (signal_== SIGUSR1)
{
gearmand_wakeup(Gearmand(), GEARMAND_WAKEUP_SHUTDOWN_GRACEFUL);
}
else
{
gearmand_wakeup(Gearmand(), GEARMAND_WAKEUP_SHUTDOWN);
}
}
extern "C" void _reset_log_handler(int, siginfo_t*, void*) // signal_arg
{
gearmand_log_info_st *log_info= static_cast<gearmand_log_info_st *>(Gearmand()->log_context);
log_info->write(GEARMAND_VERBOSE_NOTICE, "SIGHUP, reopening log file");
log_info->reset();
}
static bool segfaulted= false;
extern "C" void _crash_handler(int signal_, siginfo_t*, void*)
{
if (segfaulted)
{
error::message("\nFatal crash while backtrace from signal:", strsignal(signal_));
_exit(EXIT_FAILURE); /* Quit without running destructors */
}
segfaulted= true;
custom_backtrace();
_exit(EXIT_FAILURE); /* Quit without running destructors */
}
extern "C" {
static bool _set_signals(bool core_dump)
{
struct sigaction sa;
memset(&sa, 0, sizeof(struct sigaction));
sa.sa_handler= SIG_IGN;
if (sigemptyset(&sa.sa_mask) == -1 or
sigaction(SIGPIPE, &sa, 0) == -1)
{
error::perror("Could not set SIGPIPE handler.");
return true;
}
sa.sa_sigaction= _shutdown_handler;
sa.sa_flags= SA_SIGINFO;
if (sigaction(SIGTERM, &sa, 0) == -1)
{
error::perror("Could not set SIGTERM handler.");
return true;
}
if (sigaction(SIGINT, &sa, 0) == -1)
{
error::perror("Could not set SIGINT handler.");
return true;
}
if (sigaction(SIGUSR1, &sa, 0) == -1)
{
error::perror("Could not set SIGUSR1 handler.");
return true;
}
sa.sa_sigaction= _reset_log_handler;
if (sigaction(SIGHUP, &sa, 0) == -1)
{
error::perror("Could not set SIGHUP handler.");
return true;
}
bool in_gdb_libtest= bool(getenv("LIBTEST_IN_GDB"));
if ((in_gdb_libtest == false) and (core_dump == false))
{
sa.sa_sigaction= _crash_handler;
if (sigaction(SIGSEGV, &sa, NULL) == -1)
{
error::perror("Could not set SIGSEGV handler.");
return true;
}
if (sigaction(SIGABRT, &sa, NULL) == -1)
{
error::perror("Could not set SIGABRT handler.");
return true;
}
#ifdef SIGBUS
if (sigaction(SIGBUS, &sa, NULL) == -1)
{
error::perror("Could not set SIGBUS handler.");
return true;
}
#endif
if (sigaction(SIGILL, &sa, NULL) == -1)
{
error::perror("Could not set SIGILL handler.");
return true;
}
if (sigaction(SIGFPE, &sa, NULL) == -1)
{
error::perror("Could not set SIGFPE handler.");
return true;
}
}
return false;
}
}
static void _log(const char *mesg, gearmand_verbose_t verbose, void *context)
{
gearmand_log_info_st *log_info= static_cast<gearmand_log_info_st *>(context);
log_info->write(verbose, mesg);
}
| 29.662058 | 416 | 0.68348 | alionurdemetoglu |
2988952542ad7b50ab726e6e0e3513f94b4ab8b1 | 12,242 | cpp | C++ | src/engine/components/replay/cl_replaymoviemanager.cpp | cstom4994/SourceEngineRebuild | edfd7f8ce8af13e9d23586318350319a2e193c08 | [
"MIT"
] | 6 | 2022-01-23T09:40:33.000Z | 2022-03-20T20:53:25.000Z | src/engine/components/replay/cl_replaymoviemanager.cpp | cstom4994/SourceEngineRebuild | edfd7f8ce8af13e9d23586318350319a2e193c08 | [
"MIT"
] | null | null | null | src/engine/components/replay/cl_replaymoviemanager.cpp | cstom4994/SourceEngineRebuild | edfd7f8ce8af13e9d23586318350319a2e193c08 | [
"MIT"
] | 1 | 2022-02-06T21:05:23.000Z | 2022-02-06T21:05:23.000Z | //========= Copyright Valve Corporation, All rights reserved. ============//
//
//=======================================================================================//
#include "cl_replaymoviemanager.h"
#include "replay/ireplaymoviemanager.h"
#include "replay/ireplaymovierenderer.h"
#include "replay/replay.h"
#include "replay/replayutils.h"
#include "replay/rendermovieparams.h"
#include "replay/shared_defs.h"
#include "cl_replaymovie.h"
#include "cl_renderqueue.h"
#include "cl_replaycontext.h"
#include "filesystem.h"
#include "KeyValues.h"
#include "replaysystem.h"
#include "cl_replaymanager.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/materialsystem_config.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//----------------------------------------------------------------------------------------
#define MOVIE_MANAGER_VERSION 1
//----------------------------------------------------------------------------------------
extern IMaterialSystem *materials;
//----------------------------------------------------------------------------------------
CReplayMovieManager::CReplayMovieManager()
: m_pPendingMovie(NULL),
m_pVidModeSettings(NULL),
m_pRenderMovieSettings(NULL),
m_bIsRendering(false),
m_bRenderingCancelled(false) {
m_pVidModeSettings = new MaterialSystem_Config_t();
m_pRenderMovieSettings = new RenderMovieParams_t();
m_wszCachedMovieTitle[0] = L'\0';
}
CReplayMovieManager::~CReplayMovieManager() {
delete m_pVidModeSettings;
}
bool CReplayMovieManager::Init() {
// Create "rendered" dir
const char *pRenderedDir = Replay_va("%s%s%c", CL_GetReplayBaseDir(), SUBDIR_RENDERED, CORRECT_PATH_SEPARATOR);
g_pFullFileSystem->CreateDirHierarchy(pRenderedDir);
return BaseClass::Init();
}
int CReplayMovieManager::GetMovieCount() {
return Count();
}
void CReplayMovieManager::GetMovieList(CUtlLinkedList<IReplayMovie *> &list) {
FOR_EACH_OBJ(this, i) {
list.AddToTail(ToMovie(m_vecObjs[i]));
}
}
IReplayMovie *CReplayMovieManager::GetMovie(ReplayHandle_t hMovie) {
return ToMovie(Find(hMovie));
}
void CReplayMovieManager::AddMovie(CReplayMovie *pNewMovie) {
Add(pNewMovie);
Save();
}
CReplayMovie *CReplayMovieManager::Create() {
return new CReplayMovie();
}
const char *CReplayMovieManager::GetRelativeIndexPath() const {
return Replay_va("%s%c", SUBDIR_MOVIES, CORRECT_PATH_SEPARATOR);
}
IReplayMovie *CReplayMovieManager::CreateAndAddMovie(ReplayHandle_t hReplay) {
CReplayMovie *pNewMovie = CreateAndGenerateHandle(); // Sets m_hThis (which is accessed via GetHandle())
// Cache replay handle.
pNewMovie->m_hReplay = hReplay;
// Copy cached render settings to the movie itself.
V_memcpy(&pNewMovie->m_RenderSettings, &m_pRenderMovieSettings->m_Settings, sizeof(ReplayRenderSettings_t));
AddMovie(pNewMovie);
return pNewMovie;
}
void CReplayMovieManager::DeleteMovie(ReplayHandle_t hMovie) {
// Cache owner replay
CReplayMovie *pMovie = Find(hMovie);
CReplay *pOwnerReplay = pMovie ? CL_GetReplayManager()->GetReplay(pMovie->m_hReplay) : NULL;
Remove(hMovie);
// If no more movies for the given replay, mark as unrendered & save
if (pOwnerReplay && GetNumMoviesDependentOnReplay(pOwnerReplay) == 0) {
pOwnerReplay->m_bRendered = false;
CL_GetReplayManager()->FlagReplayForFlush(pOwnerReplay, false);
}
}
int CReplayMovieManager::GetNumMoviesDependentOnReplay(const CReplay *pReplay) {
if (!pReplay)
return 0;
// Go through all movies and find any that depend on the given replay
int nNumMovies = 0;
FOR_EACH_OBJ(this, i) {
CReplayMovie *pMovie = ToMovie(m_vecObjs[i]);
if (pMovie->m_hReplay == pReplay->GetHandle()) {
++nNumMovies;
}
}
return nNumMovies;
}
void CReplayMovieManager::SetPendingMovie(IReplayMovie *pMovie) {
m_pPendingMovie = pMovie;
}
IReplayMovie *CReplayMovieManager::GetPendingMovie() {
return m_pPendingMovie;
}
void CReplayMovieManager::FlagMovieForFlush(IReplayMovie *pMovie, bool bImmediate) {
FlagForFlush(CastMovie(pMovie), bImmediate);
}
CReplayMovie *CReplayMovieManager::CastMovie(IReplayMovie *pMovie) {
return static_cast< CReplayMovie * >( pMovie );
}
int CReplayMovieManager::GetVersion() const {
return MOVIE_MANAGER_VERSION;
}
IReplayContext *CReplayMovieManager::GetReplayContext() const {
return g_pClientReplayContextInternal;
}
float CReplayMovieManager::GetNextThinkTime() const {
return 0.1f;
}
void CReplayMovieManager::CacheMovieTitle(const wchar_t *pTitle) {
V_wcsncpy(m_wszCachedMovieTitle, pTitle, sizeof(m_wszCachedMovieTitle));
}
void CReplayMovieManager::GetCachedMovieTitleAndClear(wchar_t *pOut, int nOutBufLength) {
const int nLength = wcslen(m_wszCachedMovieTitle);
wcsncpy(pOut, m_wszCachedMovieTitle, nOutBufLength);
pOut[nLength] = L'\0';
m_wszCachedMovieTitle[0] = L'\0';
}
void CReplayMovieManager::AddReplayForRender(CReplay *pReplay, int iPerformance) {
if (!g_pClientReplayContextInternal->ReconstructReplayIfNecessary(pReplay)) {
CL_GetErrorSystem()->AddErrorFromTokenName("#Replay_Err_Render_ReconstructFailed");
return;
}
// Store in the demo player's list
g_pReplayDemoPlayer->AddReplayToList(pReplay->GetHandle(), iPerformance);
}
void CReplayMovieManager::ClearRenderCancelledFlag() {
m_bRenderingCancelled = false;
}
void CReplayMovieManager::RenderMovie(RenderMovieParams_t const ¶ms) {
// Save state
m_bIsRendering = true;
// Change video settings for recording
SetupVideo(params);
// Clear any old replays in the player
g_pReplayDemoPlayer->ClearReplayList();
// Render all unrendered replays
if (params.m_hReplay == REPLAY_HANDLE_INVALID) {
CRenderQueue *pRenderQueue = g_pClientReplayContextInternal->m_pRenderQueue;
const int nQueueCount = pRenderQueue->GetCount();
for (int i = 0; i < nQueueCount; ++i) {
ReplayHandle_t hCurReplay;
int iCurPerformance;
if (!pRenderQueue->GetEntryData(i, &hCurReplay, &iCurPerformance))
continue;
CReplay *pReplay = CL_GetReplayManager()->GetReplay(hCurReplay);
if (!pReplay)
continue;
AddReplayForRender(pReplay, iCurPerformance);
}
} else {
// Cache the title
CReplayMovieManager *pMovieManager = CL_GetMovieManager();
pMovieManager->CacheMovieTitle(params.m_wszTitle);
// Only render the specified replay
AddReplayForRender(CL_GetReplayManager()->GetReplay(params.m_hReplay), params.m_iPerformance);
}
g_pReplayDemoPlayer->PlayNextReplay();
}
void CReplayMovieManager::RenderNextMovie() {
m_bIsRendering = true;
g_pReplayDemoPlayer->PlayNextReplay();
}
void CReplayMovieManager::SetupHighDetailModels() {
g_pEngine->Cbuf_AddText("r_rootlod 0\n");
}
void CReplayMovieManager::SetupHighDetailTextures() {
g_pEngine->Cbuf_AddText("mat_picmip -1\n");
}
void CReplayMovieManager::SetupHighQualityAntialiasing() {
int nNumSamples = 1;
int nQualityLevel = 0;
if (materials->SupportsCSAAMode(8, 2)) {
nNumSamples = 8;
nQualityLevel = 2;
} else if (materials->SupportsMSAAMode(8)) {
nNumSamples = 8;
nQualityLevel = 0;
} else if (materials->SupportsCSAAMode(4, 4)) {
nNumSamples = 4;
nQualityLevel = 4;
} else if (materials->SupportsCSAAMode(4, 2)) {
nNumSamples = 4;
nQualityLevel = 2;
} else if (materials->SupportsMSAAMode(6)) {
nNumSamples = 6;
nQualityLevel = 0;
} else if (materials->SupportsMSAAMode(4)) {
nNumSamples = 4;
nQualityLevel = 0;
} else if (materials->SupportsMSAAMode(2)) {
nNumSamples = 2;
nQualityLevel = 0;
}
g_pEngine->Cbuf_AddText(Replay_va("mat_antialias %i\n", nNumSamples));
g_pEngine->Cbuf_AddText(Replay_va("mat_aaquality %i\n", nQualityLevel));
}
void CReplayMovieManager::SetupHighQualityFiltering() {
g_pEngine->Cbuf_AddText("mat_forceaniso\n");
}
void CReplayMovieManager::SetupHighQualityShadowDetail() {
if (materials->SupportsShadowDepthTextures()) {
g_pEngine->Cbuf_AddText("r_shadowrendertotexture 1\n");
g_pEngine->Cbuf_AddText("r_flashlightdepthtexture 1\n");
} else {
g_pEngine->Cbuf_AddText("r_shadowrendertotexture 1\n");
g_pEngine->Cbuf_AddText("r_flashlightdepthtexture 0\n");
}
}
void CReplayMovieManager::SetupHighQualityHDR() {
ConVarRef mat_dxlevel("mat_dxlevel");
if (mat_dxlevel.GetInt() < 80)
return;
g_pEngine->Cbuf_AddText(Replay_va("mat_hdr_level %i\n", materials->SupportsHDRMode(HDR_TYPE_INTEGER) ? 2 : 1));
}
void CReplayMovieManager::SetupHighQualityWaterDetail() {
#ifndef _X360
g_pEngine->Cbuf_AddText("r_waterforceexpensive 1\n");
#endif
g_pEngine->Cbuf_AddText("r_waterforcereflectentities 1\n");
}
void CReplayMovieManager::SetupMulticoreRender() {
g_pEngine->Cbuf_AddText("mat_queue_mode 0\n");
}
void CReplayMovieManager::SetupHighQualityShaderDetail() {
g_pEngine->Cbuf_AddText("mat_reducefillrate 0\n");
}
void CReplayMovieManager::SetupColorCorrection() {
g_pEngine->Cbuf_AddText("mat_colorcorrection 1\n");
}
void CReplayMovieManager::SetupMotionBlur() {
g_pEngine->Cbuf_AddText("mat_motion_blur_enabled 1\n");
}
void CReplayMovieManager::SetupVideo(RenderMovieParams_t const ¶ms) {
// Get current video config
const MaterialSystem_Config_t &config = materials->GetCurrentConfigForVideoCard();
// Cache config
V_memcpy(m_pVidModeSettings, &config, sizeof(config));
// Cache quit when done
V_memcpy(m_pRenderMovieSettings, ¶ms, sizeof(params));
g_pEngine->Cbuf_Execute();
}
void CReplayMovieManager::CompleteRender(bool bSuccess, bool bShowBrowser) {
// Store state
m_bIsRendering = false;
// Shutdown renderer
IReplayMovieRenderer *pRenderer = CL_GetMovieRenderer();
if (pRenderer) {
pRenderer->ShutdownRenderer();
}
if (!bSuccess) {
// Delete the movie from the manager
IReplayMovie *pMovie = CL_GetMovieManager()->GetPendingMovie();
if (pMovie) {
CL_GetMovieManager()->DeleteMovie(pMovie->GetMovieHandle());
}
}
// Clear render queue if we're done
if (bShowBrowser) {
CL_GetRenderQueue()->Clear();
}
// Notify UI that rendering is complete
g_pClient->OnRenderComplete(*m_pRenderMovieSettings, m_bRenderingCancelled, bSuccess, bShowBrowser);
// Quit now?
if (m_pRenderMovieSettings->m_bQuitWhenFinished) {
g_pEngine->HostState_Shutdown();
return;
}
// Otherwise, play a sound.
g_pClient->PlaySound("replay\\rendercomplete.wav");
}
void CReplayMovieManager::CancelRender() {
m_bRenderingCancelled = true;
CompleteRender(false, true);
g_pEngine->Host_Disconnect(false); // CReplayDemoPlayer::StopPlayback() will be called
}
void CReplayMovieManager::GetMoviesAsQueryableItems(CUtlLinkedList<IQueryableReplayItem *, int> &lstMovies) {
lstMovies.RemoveAll();
FOR_EACH_OBJ(this, i) {
lstMovies.AddToHead(ToMovie(m_vecObjs[i]));
}
}
const char *CReplayMovieManager::GetRenderDir() const {
return Replay_va("%s%s%c", g_pClientReplayContextInternal->GetBaseDir(), SUBDIR_RENDERED, CORRECT_PATH_SEPARATOR);
}
const char *CReplayMovieManager::GetRawExportDir() const {
static CFmtStr s_fmtExportDir;
CReplayTime time;
time.InitDateAndTimeToNow();
int nDay, nMonth, nYear;
time.GetDate(nDay, nMonth, nYear);
int nHour, nMin, nSec;
time.GetTime(nHour, nMin, nSec);
s_fmtExportDir.sprintf(
"%smovie_%02i%02i%04i_%02i%02i%02i%c",
GetRenderDir(),
nMonth, nDay, nYear,
nHour, nMin, nSec,
CORRECT_PATH_SEPARATOR
);
return s_fmtExportDir.Access();
}
//----------------------------------------------------------------------------------------
| 30.452736 | 118 | 0.680444 | cstom4994 |
298d359278ad51afbf71c75dfa098289dfd272a4 | 5,807 | cpp | C++ | samples/OpenGL/basic/main.cpp | KHeresy/SS6ssbpLib | 0cf4f08ae31a544f64249508cbd80289087f659d | [
"MIT"
] | null | null | null | samples/OpenGL/basic/main.cpp | KHeresy/SS6ssbpLib | 0cf4f08ae31a544f64249508cbd80289087f659d | [
"MIT"
] | null | null | null | samples/OpenGL/basic/main.cpp | KHeresy/SS6ssbpLib | 0cf4f08ae31a544f64249508cbd80289087f659d | [
"MIT"
] | null | null | null | #include <windows.h>
#include <stdio.h>
#include <iostream>
#include <GL/glew.h>
#include <GL/glut.h>
#include "./SSPlayer/SS6Player.h"
//画面サイズ
#define WIDTH (1280)
#define HEIGHT (720)
//FPS制御用
int nowtime = 0; //経過時間
int drawtime = 0; //前回の時間
//glutのコールバック関数
void mouse(int button, int state, int x, int y);
void keyboard(unsigned char key, int x, int y);
void idle(void);
void disp(void);
//アプリケーションの制御
void Init();
void update(float dt);
void relese(void);
void draw(void);
void userDataCallback(ss::Player* player, const ss::UserData* data);
void playEndCallback(ss::Player* player);
// SSプレイヤー
ss::Player *ssplayer;
ss::ResourceManager *resman;
//アプリケーションでの入力操作用
bool nextanime = false; //次のアニメを再生する
bool forwardanime = false; //前のアニメを再生する
bool pauseanime = false;
int playindex = 0; //現在再生しているアニメのインデックス
int playerstate = 0;
std::vector<std::string> animename; //アニメーション名のリスト
//アプリケーションのメイン関数関数
int main(int argc, char ** argv)
{
//ライブラリ初期化
glutInit(&argc, argv); //GLUTの初期化
//ウィンドウ作成
glutInitWindowPosition(100, 50); //ウィンドウ位置設定
glutInitWindowSize(WIDTH, HEIGHT); //ウィンドウサイズ設定
glutInitDisplayMode(GLUT_RGBA | GLUT_STENCIL | GLUT_DEPTH | GLUT_DOUBLE); //使用するバッファを設定
glutCreateWindow("Sprite Studio SS6ssbpLib Sample"); //ウィンドウタイトル
GLenum err;
err = glewInit(); //GLEWの初期化
if (err != GLEW_OK) {
std::cerr << glewGetErrorString(err) << '\n';
return 0;
}
glClearColor(0.0, 0.0, 0.2, 1.0); //背景色
//割り込み設定
glutIdleFunc(idle); //アイドルコールバック設定
glutDisplayFunc(disp); //表示コールバック設定
glutKeyboardFunc(keyboard); //キーボード入力コールバック設定
glutMouseFunc(mouse); //マウス入力コールバック設定
Init();
glutMainLoop(); //メインループ
return 0;
}
//キーボード入力コールバック
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27: //esc
relese(); //アプリケーション終了
exit(0);
break;
case 122: //z
nextanime = true;
break;
case 120: //x
forwardanime = true;
break;
case 99: //c
pauseanime = true;
break;
default:
break;
}
}
//マウス入力コールバック
void mouse(int button, int state, int x, int y)
{
}
//アイドルコールバック
void idle(void)
{
//FPSの設定
nowtime = glutGet(GLUT_ELAPSED_TIME);//経過時間を取得
int wait = nowtime - drawtime;
if (wait > 16)
{
update((float)wait / 1000.0f);
glutPostRedisplay();
drawtime = nowtime;
}
}
//描画コールバック
void disp(void)
{
//レンダリング開始時の初期化
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); //フレームバッファのクリア
glDisable(GL_STENCIL_TEST); //ステンシル無効にする
glEnable(GL_DEPTH_TEST); //深度バッファを有効にする
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); //フレームバッファへ各色の書き込みを設定
draw();
//終了処理
glDisable(GL_DEPTH_TEST); //深度テストを無効にする
glDisable(GL_ALPHA_TEST); //アルファテスト無効にする
glDisable(GL_TEXTURE_2D); //テクスチャ無効
glDisable(GL_BLEND); //ブレンドを無効にする
glutSwapBuffers();
}
//アプリケーション初期化処理
void Init()
{
/**********************************************************************************
SpriteStudioアニメーション表示のサンプルコード
Visual Studio Community 2017で動作を確認しています。
WindowsSDK(デスクトップC++ x86およびx64用のWindows10 SDK)をインストールする必要があります
プロジェクトのNuGetでglutを検索しnupengl.coreを追加してください。
ssbpとpngがあれば再生する事ができますが、Resourcesフォルダにsspjも含まれています。
**********************************************************************************/
//プレイヤーを使用する前の初期化処理
//この処理はアプリケーションの初期化で１度だけ行ってください。
ss::SSPlatformInit();
//Y方向の設定とウィンドウサイズ設定を行います
ss::SSSetPlusDirection(ss::PLUS_UP, WIDTH, HEIGHT);
//リソースマネージャの作成
resman = ss::ResourceManager::getInstance();
//プレイヤーを使用する前の初期化処理ここまで
//プレイヤーの作成
ssplayer = ss::Player::create();
//アニメデータをリソースに追加
//それぞれのプラットフォームに合わせたパスへ変更してください。
resman->addData("Resources/character_template_comipo/character_template1.ssbp");
//プレイヤーにリソースを割り当て
ssplayer->setData("character_template1"); // ssbpファイル名（拡張子不要）
//再生するモーションを設定
ssplayer->play("character_template_3head/stance"); // アニメーション名を指定(ssae名/アニメーション)
//表示位置を設定
ssplayer->setPosition(WIDTH / 2, HEIGHT / 2);
ssplayer->setScale(0.5f, 0.5f);
//ユーザーデータコールバックを設定
ssplayer->setUserDataCallback(userDataCallback);
//アニメーション終了コールバックを設定
ssplayer->setPlayEndCallback(playEndCallback);
//ssbpに含まれているアニメーション名のリストを取得する
animename = resman->getAnimeName(ssplayer->getPlayDataName());
playindex = 0; //現在再生しているアニメのインデックス
}
//アプリケーション更新
void update(float dt)
{
//プレイヤーの更新、引数は前回の更新処理から経過した時間
ssplayer->update(dt);
if (nextanime == true)
{
playindex++;
if (playindex >= animename.size())
{
playindex = 0;
}
std::string name = animename.at(playindex);
ssplayer->play(name);
nextanime = false;
}
if (forwardanime == true)
{
playindex--;
if ( playindex < 0 )
{
playindex = animename.size() - 1;
}
std::string name = animename.at(playindex);
ssplayer->play(name);
forwardanime = false;
}
if (pauseanime == true)
{
if (playerstate == 0)
{
ssplayer->animePause();
playerstate = 1;
}
else
{
ssplayer->animeResume();
playerstate = 0;
}
pauseanime = false;
}
}
//ユーザーデータコールバック
void userDataCallback(ss::Player* player, const ss::UserData* data)
{
//再生したフレームにユーザーデータが設定されている場合呼び出されます。
//プレイヤーを判定する場合、ゲーム側で管理しているss::Playerのアドレスと比較して判定してください。
/*
//コールバック内でパーツのステータスを取得したい場合は、この時点ではアニメが更新されていないため、
//getPartState に data->frameNo でフレーム数を指定して取得してください。
ss::ResluteState result;
//再生しているモーションに含まれるパーツ名「collision」のステータスを取得します。
ssplayer->getPartState(result, "collision", data->frameNo);
*/
}
//アニメーション終了コールバック
void playEndCallback(ss::Player* player)
{
//再生したアニメーションが終了した段階で呼び出されます。
//プレイヤーを判定する場合、ゲーム側で管理しているss::Playerのアドレスと比較して判定してください。
//player->getPlayAnimeName();
//を使用する事で再生しているアニメーション名を取得する事もできます。
//ループ回数分再生した後に呼び出される点に注意してください。
//無限ループで再生している場合はコールバックが発生しません。
}
//アプリケーション描画
void draw(void)
{
//プレイヤーの描画
ssplayer->draw();
}
//アプリケーション終了処理
void relese(void)
{
//SSPlayerの削除
delete (ssplayer);
delete (resman);
ss::SSPlatformRelese( );
}
| 20.81362 | 91 | 0.700017 | KHeresy |
298d63aea0d103907212ce09aea06bdbfb1a4975 | 224 | hpp | C++ | tools/TP/TP.hpp | jon-dez/easy-imgui | 06644279045c167e300b346f094f3dbebcbc963b | [
"MIT"
] | null | null | null | tools/TP/TP.hpp | jon-dez/easy-imgui | 06644279045c167e300b346f094f3dbebcbc963b | [
"MIT"
] | null | null | null | tools/TP/TP.hpp | jon-dez/easy-imgui | 06644279045c167e300b346f094f3dbebcbc963b | [
"MIT"
] | null | null | null | #include <functional>
#include <sstream>
namespace TP {
void prepare_pool(uint32_t number_threads = 0);
void add_job(std::function<void()> job);
void join_pool();
const std::stringstream& message_stream();
} | 24.888889 | 51 | 0.700893 | jon-dez |
299745dd1c98b88a7f73e5c8b93b2f38c014d1d2 | 350 | cpp | C++ | restbed/test/regression/source/missing_regex_support_on_gcc_4.8.cpp | stevens2017/Aware | cd4754a34c809707c219a173dc1ad494e149cdb1 | [
"BSD-3-Clause"
] | null | null | null | restbed/test/regression/source/missing_regex_support_on_gcc_4.8.cpp | stevens2017/Aware | cd4754a34c809707c219a173dc1ad494e149cdb1 | [
"BSD-3-Clause"
] | null | null | null | restbed/test/regression/source/missing_regex_support_on_gcc_4.8.cpp | stevens2017/Aware | cd4754a34c809707c219a173dc1ad494e149cdb1 | [
"BSD-3-Clause"
] | null | null | null | /*
* Copyright 2013-2017, Corvusoft Ltd, All Rights Reserved.
*/
//System Includes
#include <regex>
//Project Includes
//External Includes
#include <catch.hpp>
//System Namespaces
//Project Namespaces
using std::regex;
//External Namespaces
TEST_CASE( "missing regex support", "[stdlib]" )
{
REQUIRE_NOTHROW( regex( "(abc[1234])" ) );
}
| 14.583333 | 59 | 0.694286 | stevens2017 |
2998a6a26e60531b0845f7a99fac81d96dea1b83 | 431 | hpp | C++ | simulations/landau/params.yaml.hpp | gyselax/gyselalibxx | 5f9b4b1e20050f87e2a9f05d510bedf0f9a15b34 | [
"MIT"
] | 3 | 2022-02-28T08:47:07.000Z | 2022-03-01T10:29:08.000Z | simulations/landau/params.yaml.hpp | gyselax/gyselalibxx | 5f9b4b1e20050f87e2a9f05d510bedf0f9a15b34 | [
"MIT"
] | null | null | null | simulations/landau/params.yaml.hpp | gyselax/gyselalibxx | 5f9b4b1e20050f87e2a9f05d510bedf0f9a15b34 | [
"MIT"
] | null | null | null | // SPDX-License-Identifier: MIT
#pragma once
constexpr char const* const params_yaml = R"PDI_CFG(Mesh:
x_min: 0.0
x_max: 12.56637061435917
x_size: 128
vx_min: -6.0
vx_max: +6.0
vx_size: 127
SpeciesInfo:
- charge: -1
mass: 0.0005
density_eq: 1.
temperature_eq: 1.
mean_velocity_eq: 0.
perturb_amplitude: 0.01
perturb_mode: 1
Algorithm:
deltat: 0.125
nbiter: 360
Output:
time_diag: 0.25
)PDI_CFG";
| 14.862069 | 57 | 0.693735 | gyselax |
299ae8675a8186dbfd9a19603c91c7f05f292fa4 | 2,759 | cpp | C++ | wxMsRunMailClient.cpp | tester0077/wxMS | da7b8aaefa7107f51b7ecab05c07c109d09f933f | [
"Zlib",
"MIT"
] | null | null | null | wxMsRunMailClient.cpp | tester0077/wxMS | da7b8aaefa7107f51b7ecab05c07c109d09f933f | [
"Zlib",
"MIT"
] | null | null | null | wxMsRunMailClient.cpp | tester0077/wxMS | da7b8aaefa7107f51b7ecab05c07c109d09f933f | [
"Zlib",
"MIT"
] | null | null | null | /*-----------------------------------------------------------------
* Name: wxMsRunMailClient.cpp
* Purpose: code to invoke the external mail client - eg: Thunderbird
* Author: A. Wiegert
*
* Copyright:
* Licence: wxWidgets license
*---------------------------------------------------------------- */
/*----------------------------------------------------------------
* Standard wxWidgets headers
*---------------------------------------------------------------- */
// Note __VISUALC__ is defined by wxWidgets, not by MSVC IDE
// and thus won't be defined until some wxWidgets headers are included
#if defined( _MSC_VER )
# if defined ( _DEBUG )
// this statement NEEDS to go BEFORE all headers
# define _CRTDBG_MAP_ALLOC
# endif
#endif
#include "wxMsPreProcDefsh.h" // needs to be first
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
/* For all others, include the necessary headers
* (this file is usually all you need because it
* includes almost all "standard" wxWidgets headers) */
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
// ------------------------------------------------------------------
#include "wxMsFrameh.h"
// ------------------------------------------------------------------
// Note __VISUALC__ is defined by wxWidgets, not by MSVC IDE
// and thus won't be defined until some wxWidgets headers are included
#if defined( _MSC_VER )
// only good for MSVC
// this block needs to go AFTER all headers
#include <crtdbg.h>
#ifdef _DEBUG
#ifndef DBG_NEW
#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
#define new DBG_NEW
#endif
#endif
#endif
// ------------------------------------------------------------------
void MyFrame::OnLaunchMailClient(wxCommandEvent& event)
{
event.Skip();
if ( !g_iniPrefs.data[IE_MAIL_CLIENT_PATH].dataCurrent.wsVal.IsEmpty() )
{
InvokeMailClient( g_iniPrefs.data[IE_MAIL_CLIENT_PATH].dataCurrent.wsVal );
}
else
{
wxString wsT;
wsT.Printf( _("No E-Mail client defined!\n") );
wxMessageBox( wsT, "Error", wxOK );
return;
}
}
// ------------------------------------------------------------------
bool MyFrame::InvokeMailClient( wxString wsClientPath )
{
wxString wsT;
wxTextAttr wtaOld;
wsT = _("Invoking mail client ") + wsClientPath;
wxLogMessage( wsT );
wxString wsCmd;
// adding -mail does not show the GUI??, does TB run??
wsCmd = wsClientPath;// + _T(" -mail");
if ( g_iniPrefs.data[IE_LOG_VERBOSITY].dataCurrent.lVal > 0 )
{
wxLogMessage( _T("wsCmd: ") + wsCmd );
}
wxExecute( wsCmd );
return true;
}
// ------------------------------- eof ------------------------------
| 29.666667 | 79 | 0.540051 | tester0077 |
299c6e360b33ef7676eab2cc58b806bb55ba12e9 | 18,700 | cpp | C++ | Source/WndSpyGui/SpyMsgWnd.cpp | Skight/wndspy | b89cc2df88ca3e58b26be491814008aaf6f11122 | [
"Apache-2.0"
] | 24 | 2017-03-16T05:32:44.000Z | 2021-12-11T13:49:07.000Z | Source/WndSpyGui/SpyMsgWnd.cpp | zhen-e-liu/wndspy | b89cc2df88ca3e58b26be491814008aaf6f11122 | [
"Apache-2.0"
] | null | null | null | Source/WndSpyGui/SpyMsgWnd.cpp | zhen-e-liu/wndspy | b89cc2df88ca3e58b26be491814008aaf6f11122 | [
"Apache-2.0"
] | 13 | 2017-03-16T05:26:12.000Z | 2021-07-04T16:24:42.000Z | #include "WndSpyGui.h"
#include "SndMsgFunc.h"
#include "SpyMsgWnd.h"
//////////////////////////////////////////////////////////////////////////
LRESULT OnMainTrayNotify(HWND hwnd, LPARAM lParam);
//////////////////////////////////////////////////////////////////////////
LRESULT CALLBACK WndProc_MsgBackWnd(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HICON hIconGreyGoBtn = (HICON)LoadImage(g_hInstance,
MAKEINTRESOURCE(IDI_ICON_GOTO_GREY), IMAGE_ICON, 16, 16, LR_SHARED);
INT iBuf;
TCHAR strBuf[MAX_PATH];
switch (message)
{
case WM_CREATE:
{
//Set g_hwndBK firstly...
g_hwndBK = hwnd;
if(g_option.SpyHotkey.wEnableFlag)
{
g_option.SpyHotkey.wEnableFlag=(WORD)
DoRegisterHotKey(hwnd, ID_HOTKEY_SPYIT, g_option.SpyHotkey.Hotkey, TRUE);
}
return 0;
}
case WM_HOTKEY:
{
if( wParam==ID_HOTKEY_SPYIT )
{
SetTimer(g_TabDlgHdr.CDI[TAB_FINDER].hwnd,
FINDER_TIMER_HOTKEY_SPYIT, g_option.SpyHotkey.wDelay, NULL);
}
break;
}
case WM_SETTEXT:
{
if( lstrcmpi((LPTSTR)lParam,SPY_HOOK_SIGNAL)==0 )
{
g_isHookSignal=TRUE;
SetTimer(hwnd, TIMER_FORWARD_HOOK_SPYWNDINFO, USER_TIMER_MINIMUM, NULL);
}
else if( lstrcmpi((LPTSTR)lParam, SPY_BASE_SIGNAL)==0 )
{
g_isHookSignal=FALSE;
GetModuleFileName(NULL, strBuf, MAX_PATH);
if( lstrcmpi(g_spyinfo_SWIex.szWndModuleName, strBuf)==0 )
{
lstrcpyn(g_spyinfo_SWIex.szWndModuleName,
g_spyinfo_SPI.pe32.szExeFile, MAX_PATH);
}
if( lstrcmpi(g_spyinfo_SWIex.szClassModuleName, strBuf)==0 )
{
lstrcpyn(g_spyinfo_SWIex.szClassModuleName,
g_spyinfo_SPI.pe32.szExeFile, MAX_PATH);
}
SendMessage(hwnd, WM_MY_PRINT_SPYWNDINFO, 0, 0);
if( g_siWinVer>WINVER_WIN9X &&
lstrlen(g_spyinfo_SPI.ProcStrs.szCommandLine) > DEF_CMDLINE_STR_LEN )
{
SetTimer(hwnd, TIMER_FORWARD_SHOWLONGCMDLINE, USER_TIMER_MINIMUM, NULL);
}
}
break;
}
case WM_MY_PRINT_SPYWNDINFO:
{
if(lstrcmpi(g_spyinfo_SWIex.swi.szClassName, WNDCLASS_DESKTOP)==0)
{
wsprintf(strBuf, g_szFormat, g_spyinfo_SWIex.swi.hwnd);
lstrcat(strBuf, TEXT(" (Desktop)"));
SetDlgItemText(g_TabDlgHdr.CDI[0].hwnd, IDC_EDIT_HWND, strBuf);
SetDlgItemText(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_HWND, strBuf);
}
else
{
DlgItemPrintf(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_HWND,
g_szFormat, g_spyinfo_SWIex.swi.hwnd);
}
if( g_spyinfo_SWIex.swi.isLargeText ||
lstrcmpi(g_spyinfo_SWIex.swi.szClassName, TEXT("MS_WINNOTE"))==0 )
{
CopyWndTextToWnd(g_spyinfo_SWIex.swi.hwnd,
GetDlgItem(g_TabDlgHdr.CDI[0].hwnd, IDC_EDIT_CAPTION),
MAX_CAPTION_STRBUF_LEN, NULL, g_hInstance, IDS_TIP_OMISSION);
CopyWndTextToWnd(g_spyinfo_SWIex.swi.hwnd,
GetDlgItem(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_CAPTION),
MAX_STRBUF_LEN, NULL, NULL, NULL);
}
else
{
SetDlgItemText(g_TabDlgHdr.CDI[1].hwnd,
IDC_EDIT_CAPTION, g_spyinfo_SWIex.swi.szCaption);
}
SetDlgItemText(g_TabDlgHdr.CDI[1].hwnd,
IDC_EDIT_CLASS, g_spyinfo_SWIex.swi.szClassName);
DlgItemPrintf(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_WNDRECT,
TEXT("(%d,%d)-(%d,%d) %dx%d"),
g_spyinfo_SWIex.wi.rcWindow.left,
g_spyinfo_SWIex.wi.rcWindow.top,
g_spyinfo_SWIex.wi.rcWindow.right,
g_spyinfo_SWIex.wi.rcWindow.bottom,
g_spyinfo_SWIex.wi.rcWindow.right - g_spyinfo_SWIex.wi.rcWindow.left,
g_spyinfo_SWIex.wi.rcWindow.bottom - g_spyinfo_SWIex.wi.rcWindow.top);
DlgItemPrintf(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_CLIENTRECT,
TEXT("(%d,%d)-(%d,%d) %dx%d"),
g_spyinfo_SWIex.wi.rcClient.left,
g_spyinfo_SWIex.wi.rcClient.top,
g_spyinfo_SWIex.wi.rcClient.right,
g_spyinfo_SWIex.wi.rcClient.bottom,
g_spyinfo_SWIex.wi.rcClient.right - g_spyinfo_SWIex.wi.rcClient.left,
g_spyinfo_SWIex.wi.rcClient.bottom - g_spyinfo_SWIex.wi.rcClient.top);
DlgItemPrintf(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_HINSTANCE,
g_szFormat, g_spyinfo_SWIex.hWndInstance);
if(g_spyinfo_SWIex.wndproc)
{
DlgItemPrintf(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_WNDPROC,
g_option.IsPrefix? TEXT("0x%08X%s"):TEXT("%08X%s"),
g_spyinfo_SWIex.wndproc,
IsWindowUnicode(g_spyinfo_SWIex.swi.hwnd)? TEXT(" (Unicode)"):TEXT("") );
}
else
{
DlgItemPrintf(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_WNDPROC,
TEXT("(n/a)%s"),
IsWindowUnicode(g_spyinfo_SWIex.swi.hwnd)? TEXT(" (Unicode)"):TEXT("") );
}
// GetMenu() can do more than GetDlgCtrlID() now,
// but according to MSDN, we can't assert what GetMenu will do in the futher.
// so...
if(g_spyinfo_SWIex.wi.dwStyle&WS_CHILD)
{
iBuf=GetDlgCtrlID(g_spyinfo_SWIex.swi.hwnd);
DlgItemPrintf(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_WNDID,
g_option.IsPrefix? TEXT("0x%08X (%d)"):TEXT("%08X (%d)"),
iBuf, iBuf);
}
else
{
iBuf=(INT)GetMenu(g_spyinfo_SWIex.swi.hwnd);
if(iBuf)
{
DlgItemPrintf(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_WNDID,
g_szFormat, iBuf);
}
else
{
SetDlgItemText(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_WNDID, STR_NONE);
}
}
HICON hIconBig, hIconSmall;
if( lstrcmpi(g_spyinfo_SWIex.swi.szClassName, TEXT("Static"))==0 &&
IS_FLAGS_MARKED(g_spyinfo_SWIex.wi.dwStyle, SS_ICON|WS_CHILD) )
{
SendMessageTimeout(g_spyinfo_SWIex.swi.hwnd,
STM_GETIMAGE, IMAGE_ICON, 0,
SMTO_NOTIMEOUTIFNOTHUNG, 100, (PDWORD_PTR)&hIconBig);
hIconSmall=hIconBig;
}
else
{
SendMessageTimeout(g_spyinfo_SWIex.swi.hwnd,
WM_GETICON, ICON_BIG, 0,
SMTO_NOTIMEOUTIFNOTHUNG, 100, (PDWORD_PTR)&hIconBig);
SendMessageTimeout(g_spyinfo_SWIex.swi.hwnd,
WM_GETICON, ICON_SMALL, 0,
SMTO_NOTIMEOUTIFNOTHUNG, 100, (PDWORD_PTR)&hIconSmall);
}
DoSetCtrlIcon(g_TabDlgHdr.CDI[1].hwnd, IDC_ICONBTN_BIG, hIconBig, 32);
DoSetCtrlIcon(g_TabDlgHdr.CDI[1].hwnd, IDC_ICONBTN_SMALL, hIconSmall, 16);
DlgItemPrintf(g_TabDlgHdr.CDI[2].hwnd, IDC_EDIT_WS,
g_szFormat, g_spyinfo_SWIex.wi.dwStyle);
DlgItemPrintf(g_TabDlgHdr.CDI[2].hwnd, IDC_EDIT_WSEX,
g_szFormat, g_spyinfo_SWIex.wi.dwExStyle);
SetDlgItemText(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_CLASS,
g_spyinfo_SWIex.swi.szClassName);
DlgItemPrintf(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_CLSATOM,
g_option.IsPrefix? TEXT("0x%04X"):TEXT("%04X"),
LOWORD(g_spyinfo_SWIex.wcex.lpszClassName));
DlgItemPrintf(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_CS,
g_szFormat, g_spyinfo_SWIex.wcex.style);
DoSetCtrlIcon(g_TabDlgHdr.CDI[3].hwnd, IDC_SICON_BIG, g_spyinfo_SWIex.wcex.hIcon, 32);
DoSetCtrlIcon(g_TabDlgHdr.CDI[3].hwnd, IDC_SICON_SMALL, g_spyinfo_SWIex.wcex.hIconSm, 16);
DoSetCtrlCursor(g_TabDlgHdr.CDI[3].hwnd, IDC_SICON_CURSOR, g_spyinfo_SWIex.wcex.hCursor, 32);
if( !g_spyinfo_SWIex.wcex.hIcon && !g_spyinfo_SWIex.wcex.hIconSm )
{
SetDlgItemText(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_HICON, STR_NONE);
}
else if( g_spyinfo_SWIex.wcex.hIcon && g_spyinfo_SWIex.wcex.hIconSm )
{
DlgItemPrintf(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_HICON,
g_option.IsPrefix? TEXT("0x%08X%s 0x%08X%s"):TEXT("%08X%s\t%08X%s"),
g_spyinfo_SWIex.wcex.hIcon, TEXT("(Big)"),
g_spyinfo_SWIex.wcex.hIconSm, TEXT("(Small)"));
}
else
{
DlgItemPrintf(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_HICON,
g_option.IsPrefix? TEXT("0x%08X%s"):TEXT("%08X%s"),
g_spyinfo_SWIex.wcex.hIcon? g_spyinfo_SWIex.wcex.hIcon:g_spyinfo_SWIex.wcex.hIconSm,
g_spyinfo_SWIex.wcex.hIcon? TEXT("(Big)"):TEXT("(Small)"));
}
if(g_spyinfo_SWIex.wcex.hCursor)
{
DlgItemPrintf(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_HCURSOR,
g_szFormat, g_spyinfo_SWIex.wcex.hCursor);
}
else
{
SetDlgItemText(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_HCURSOR,
STR_NONE);
}
if(g_spyinfo_SWIex.wcex.hbrBackground)
{
DlgItemPrintf(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_HBKBRUSH,
g_szFormat,
g_spyinfo_SWIex.wcex.hbrBackground);
}
else
{
SetDlgItemText(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_HBKBRUSH, STR_NONE);
}
DlgItemPrintf(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_CLSWNDPROC,
g_szFormat, g_spyinfo_SWIex.wcex.lpfnWndProc);
DlgItemPrintf(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_HCLSMUDLE,
g_szFormat, g_spyinfo_SWIex.wcex.hInstance);
SetDlgItemText(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_MENUNAME,
g_spyinfo_SWIex.szClassMenuName);
SetDlgItemText(g_TabDlgHdr.CDI[3].hwnd, IDC_EDIT_MODULEFILE,
g_spyinfo_SWIex.szClassModuleName);
SetWindowVisible(g_TabDlgHdr.CDI[3].hwnd,IDC_BTN_LOCATE,
IsFileExists(g_spyinfo_SWIex.szClassModuleName));
SetWindowVisible(g_TabDlgHdr.CDI[4].hwnd,IDC_BTN_LOCATE1,
IsFileExists(g_spyinfo_SPI.pe32.szExeFile));
SetWindowVisible(g_TabDlgHdr.CDI[4].hwnd,IDC_BTN_LOCATE2,
IsFileExists(g_spyinfo_SWIex.szWndModuleName));
DlgItemPrintf(g_TabDlgHdr.CDI[4].hwnd, IDC_EDIT_PID,
g_szFormat,
g_spyinfo_SPI.pe32.th32ProcessID);
DlgItemPrintf(g_TabDlgHdr.CDI[4].hwnd, IDC_EDIT_TID,
g_szFormat,
g_spyinfo_SPI.dwThreadID);
DlgItemPrintf(g_TabDlgHdr.CDI[4].hwnd, IDC_EDIT_PRIORITY,
g_option.IsPrefix? TEXT("(%d)-(0x%08X)"):TEXT("(%d)-(%08X)"),
g_spyinfo_SPI.pe32.pcPriClassBase,
g_spyinfo_SPI.pe32.dwFlags);
if(g_spyinfo_SPI.pe32.cntThreads)
{
DlgItemPrintf(g_TabDlgHdr.CDI[4].hwnd, IDC_EDIT_THREADNUM,
TEXT("%d"), g_spyinfo_SPI.pe32.cntThreads);
}
else
{
SetDlgItemText(g_TabDlgHdr.CDI[4].hwnd, IDC_EDIT_THREADNUM,
TEXT("(n/a)"));
}
SetDlgItemText(g_TabDlgHdr.CDI[4].hwnd, IDC_EDIT_CURDIR,
g_spyinfo_SPI.ProcStrs.szCurrentDirectory);
SetDlgItemText(g_TabDlgHdr.CDI[4].hwnd, IDC_EDIT_CMDLINE,
g_spyinfo_SPI.ProcStrs.szCommandLine);
SetDlgItemText(g_TabDlgHdr.CDI[4].hwnd, IDC_EDIT_IMAGEFILE,
g_spyinfo_SPI.pe32.szExeFile);
SetDlgItemText(g_TabDlgHdr.CDI[4].hwnd, IDC_EDIT_WNDMODULE,
g_spyinfo_SWIex.szWndModuleName);
DlgItemPrintf(g_TabDlgHdr.CDI[5].hwnd, IDC_CBDL_HWND,
SndMsgOpt_IsDec(g_smHdr.SMO.dwFlagSMH)? TEXT("%u"):g_szFormat,
g_spyinfo_SWIex.swi.hwnd);
g_dwBitFlag|=BOOLEAN_BIT_TABS;
//if not Finder Tabpage, print all spyinfo at once...
if(g_TabDlgHdr.iCurrent)
{
SendMessage(g_TabDlgHdr.CDI[g_TabDlgHdr.iCurrent].hwnd, WM_SHOWWINDOW, TRUE, 0);
}
//////////////////////////////////////////////////////////////////////////
#ifdef _WNDSPY_ALWAYSSHOWMAINDLG
if( IsMainWndHidden(g_hwnd) )
{
ShowWindow(g_hwnd, SW_RESTORE);
}
#endif
//////////////////////////////////////////////////////////////////////////
return 0;
} //WM_MY_PRINT_SPYWNDINFO
case WM_TIMER:
{
switch (wParam)
{
case TIMER_FORWARD_HOOK_SPYWNDINFO:
{
KillTimer(hwnd, wParam);
iBuf=SpyLib_ReadWndInfoEx(&g_spyinfo_SPI, &g_spyinfo_SWIex);
SendMessage(hwnd, WM_MY_PRINT_SPYWNDINFO, (WPARAM)1, (LPARAM)0);
if( iBuf==0 || iBuf>SPYDLL_CMDLINE_STR_LEN )
{
if( g_siWinVer>WINVER_WIN9X )
{
SetTimer(hwnd, TIMER_FORWARD_SHOWLONGCMDLINE, USER_TIMER_MINIMUM, NULL);
}
}
return 0;
}
case TIMER_FORWARD_HOOK_SPYWNDINFO_TIMEOUT:
{
KillTimer(hwnd,wParam);
if(g_isHookSignal==FALSE)
{
SpyTryGetWndInfoEx(g_spyinfo_SWIex.swi.hwnd, &g_spyinfo_SPI, &g_spyinfo_SWIex);
}
return 0;
}
case TIMER_FORWARD_SHOWLONGCMDLINE:
{
KillTimer(hwnd,wParam);
GetProcessInfoDirStrs(g_spyinfo_SPI.pe32.th32ProcessID,
&g_spyinfo_SPI.ProcStrs, GetDlgItem(g_TabDlgHdr.CDI[TAB_PROCESS].hwnd, IDC_EDIT_CMDLINE));
return 0;
}
case IDC_EDIT_HWND:
{
if(g_spyinfo_SWIex.swi.hwnd && !IsWindow(g_spyinfo_SWIex.swi.hwnd) )
{
KillTimer(hwnd,wParam);
DlgItemPrintf(g_TabDlgHdr.CDI[0].hwnd, IDC_EDIT_HWND,
g_option.IsPrefix? TEXT("0x%08X %s"):TEXT("%08X %s"),
g_spyinfo_SWIex.swi.hwnd,TEXT("(Destroyed)"));
DlgItemPrintf(g_TabDlgHdr.CDI[1].hwnd, IDC_EDIT_HWND,
g_option.IsPrefix? TEXT("0x%08X %s"):TEXT("%08X %s"),
g_spyinfo_SWIex.swi.hwnd,TEXT("(Destroyed)"));
g_spyinfo_SWIex.IsSelf=0;
g_dwBitFlag|=BOOLEAN_BIT_TAB_MANI;
if(g_TabDlgHdr.iCurrent==5)
{
SendMessage(g_TabDlgHdr.CDI[5].hwnd,WM_SHOWWINDOW, TRUE, 0);
}
}
return 0;
}
case IDC_EDIT_OWNER:
case IDC_EDIT_PARENT:
case IDC_EDIT_CHILD:
case IDC_EDIT_NEXT:
case IDC_EDIT_PRE:
{
if( g_spyinfo_SWIex.swi.hwndArray[wParam-IDC_EDIT_OWNER] &&
!IsWindow(g_spyinfo_SWIex.swi.hwndArray[wParam-IDC_EDIT_OWNER]) )
{
KillTimer(hwnd,wParam);
DlgItemPrintf(g_TabDlgHdr.CDI[0].hwnd, wParam,
g_option.IsPrefix? TEXT("0x%08X %s"):TEXT("%08X %s"),
g_spyinfo_SWIex.swi.hwndArray[wParam-IDC_EDIT_OWNER],
TEXT("(Destroyed)"));
SendDlgItemMessage(g_TabDlgHdr.CDI[0].hwnd, wParam + IDC_BTN_OWNER-IDC_EDIT_OWNER,
STM_SETIMAGE, IMAGE_ICON, (LPARAM)hIconGreyGoBtn);
EnableWindow(GetDlgItem(g_TabDlgHdr.CDI[0].hwnd,
wParam + IDC_BTN_OWNER-IDC_EDIT_OWNER), FALSE);
}
return 0;
}
case TIMER_SHOW_LOADING:
{
KillTimer(hwnd,wParam);
DialogBox(g_hInstance, MAKEINTRESOURCE(IDD_LOADING), g_hwnd, DlgProc_Loading);
return 0;
}
}// end switch(wParam) @ WM_TIMER ...
return 0;
} //WM_TIMER end...
case WM_MY_NOTIFYICON:
{
return OnMainTrayNotify(hwnd, lParam);
}
case WM_COMMAND:
{
switch( LOWORD(wParam) )
{
case ID_CMD_SPYTARGET:
{
if( IsWindow((HWND)lParam) )
{
g_spyinfo_SWIex.swi.hwnd=(HWND)lParam;
SetTimer(g_TabDlgHdr.CDI[TAB_FINDER].hwnd,
FINDER_TIMER_GETSPYINFOEX, USER_TIMER_MINIMUM, NULL);
DoPlayEventSound(g_option.IsPlaySound);
BringWindowToForeground(g_hwnd);
}
else
{
MessageBeep(0);
}
break;
}
}
return 0;
}
case WM_GETMINMAXINFO:
{
((LPMINMAXINFO)lParam)->ptMaxPosition.x = -1;
((LPMINMAXINFO)lParam)->ptMaxPosition.y = -1;
((LPMINMAXINFO)lParam)->ptMaxSize.x = 0;
((LPMINMAXINFO)lParam)->ptMaxSize.y = 0;
return 0;
}
//never let this window show...
case WM_SETFOCUS:
{
ShowWindow(hwnd, SW_HIDE);
break;
}
#ifdef APP_FUNC_ONSETTOOLTIPCOLOR
case WM_SYSCOLORCHANGE:
{
PostMessage(hwnd,WM_MY_COLORSET,0,0);
break;
}
case WM_MY_COLORSET:
{
OnSetTooltipColor();
return 0;
}
#endif //APP_FUNC_ONSETTOOLTIPCOLOR
case WM_DESTROY:
{
NotifyIconMessage(hwnd, ID_TRAYICON_MAIN, NIM_DELETE,
WM_MY_NOTIFYICON, NULL, NULL, NULL, NULL);
break;
}
} //switch(message) end...
return DefWindowProc(hwnd, message, wParam, lParam);
} //WndProc_MsgBackWnd() end...
//////////////////////////////////////////////////////////////////////////
LRESULT OnMainTrayNotify(HWND hwnd, LPARAM lParam)
{
TCHAR strBuf[MAX_PATH];
if( IsWindow(g_hwnd_TaskModal) &&
(lParam == WM_RBUTTONUP ||
lParam == WM_LBUTTONDBLCLK) )
{
MessageBeep(0);
BringWindowToForeground(g_hwnd_TaskModal);
return 1;
}
else if (lParam == WM_RBUTTONUP)
{
HMENU hMenu;
hMenu=CreatePopupMenu();
if( IsMainWndHidden(g_hwnd) )
{
if(!IsWindowVisible(g_hwnd))
{
LoadString(g_hInstance, IDS_SHOW_MAINDLG, strBuf, MAX_PATH);
}
else
{
GetMenuString(GetSystemMenu(g_hwnd,FALSE), SC_RESTORE,
strBuf, MAX_PATH, MF_BYCOMMAND);
}
AppendMenu(hMenu, MF_STRING, SC_RESTORE, strBuf);
AppendMenu(hMenu, MF_SEPARATOR, 0, NULL);
SetMenuDefaultItem(hMenu, SC_RESTORE, FALSE);
}
HMENU hSubMenu;
hSubMenu=LoadMenu(g_hInstance, MAKEINTRESOURCE(IDR_MAIN_MENU));
GetMenuString(hSubMenu, 1, strBuf, MAX_PATH, MF_BYPOSITION);
AppendMenu(hMenu, MF_POPUP, (UINT)GetSubMenu(hSubMenu,1), strBuf);
GetMenuString(hSubMenu, 2, strBuf, MAX_PATH, MF_BYPOSITION);
AppendMenu(hMenu, MF_POPUP, (UINT)GetSubMenu(hSubMenu,2), strBuf);
AppendMenu(hMenu, MF_SEPARATOR, 0, NULL) ;
GetMenuString(hSubMenu, ID_CMD_EXIT, strBuf, MAX_PATH, MF_BYCOMMAND);
AppendMenu(hMenu, MF_STRING, ID_CMD_EXIT, strBuf);
OnSetMenuState(hMenu);
POINT point;
GetCursorPos(&point);
SetForegroundWindow(hwnd);
lParam=TrackPopupMenu(hMenu, TPM_RETURNCMD|TPM_RIGHTBUTTON, point.x, point.y, 0, hwnd, NULL);
PostMessage(hwnd, WM_NULL, 0, 0);
DestroyMenu(hSubMenu);
DestroyMenu(hMenu);
if(lParam)
{
PostMessage(g_hwnd, WM_COMMAND, MAKELPARAM(lParam,0), 0);
}
}
else if (lParam == WM_LBUTTONDBLCLK)
{
// TODO: bring tool-windows to top...
BringWindowToForeground(g_hwnd);
if( IsWindow(g_hwndTC) )
{
SetForegroundWindow(g_hwndTC);
}
}
return 0;
}
//////////////////////////////////////////////////////////////////////////
BOOL CALLBACK DlgProc_Loading(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
#define PROGRESS_DEF_RANGE 1000
switch (message)
{
case WM_INITDIALOG:
{
g_hwnd_TaskModal=hwnd;
g_hTarget=(HANDLE)GetDlgItem(hwnd, IDC_PROGRESS);
MoveWndToWndCenter(hwnd, g_hwnd);
return TRUE;
}
case WM_MY_LOADING_STATE:
{
if(lParam==TRUE)
{
SendMessage((HWND)g_hTarget, PBM_SETRANGE32, 0, PROGRESS_DEF_RANGE);
SendMessage((HWND)g_hTarget, PBM_SETPOS, 0, 0);
SetTimer(hwnd,
TIMER_PROGRESS_EFFECT, USER_TIMER_MINIMUM, NULL);
}
else
{
SendMessage((HWND)g_hTarget, PBM_SETPOS,
(WPARAM)SendMessage((HWND)g_hTarget, PBM_GETRANGE, FALSE, NULL), 0);
EnableWindow(hwnd, FALSE);
Sleep(100);
EndDialog(hwnd, 0);
}
return TRUE;
}
case WM_TIMER:
{
// terrible bogus progress bar effect codes
// but still...
// just put them here...
INT iPos;
iPos = SendMessage((HWND)g_hTarget, PBM_GETPOS, 0, 0);
if( iPos >= PROGRESS_DEF_RANGE-1 )
{
KillTimer(hwnd, TIMER_PROGRESS_EFFECT);
}
else if( iPos >= PROGRESS_DEF_RANGE-400 && (iPos%50==0) )
{
SetTimer(hwnd, TIMER_PROGRESS_EFFECT, iPos/5, NULL);
}
else if( iPos > PROGRESS_DEF_RANGE-768 &&
iPos < PROGRESS_DEF_RANGE-384 )
{
if( 0 == (iPos%50) )
{
SetTimer(hwnd, TIMER_PROGRESS_EFFECT,
max(USER_TIMER_MINIMUM, iPos%32), NULL);
}
}
SendMessage((HWND)g_hTarget, PBM_SETPOS, min(PROGRESS_DEF_RANGE, iPos+1), 0);
return TRUE;
}
case WM_LBUTTONDOWN:
{
PostMessage(hwnd, WM_NCLBUTTONDOWN, (WPARAM)HTCAPTION, 0);
break;
}
case WM_DESTROY:
{
g_hTarget=NULL;
g_hwnd_TaskModal=NULL;
break;
}
}//switch message...
return FALSE;
} //DlgProc_Loading()
////////////////////////////////////////////////////////////////////////// | 28.593272 | 96 | 0.671925 | Skight |
299d2fa28bb07ff75bdc1f9b25d27f81564859c9 | 7,563 | cpp | C++ | modules/qtwidgets/src/qtwidgetssettings.cpp | tirpidz/inviwo | a0ef149fac0e566ef3f0298112e2031d344f2f97 | [
"BSD-2-Clause"
] | null | null | null | modules/qtwidgets/src/qtwidgetssettings.cpp | tirpidz/inviwo | a0ef149fac0e566ef3f0298112e2031d344f2f97 | [
"BSD-2-Clause"
] | null | null | null | modules/qtwidgets/src/qtwidgetssettings.cpp | tirpidz/inviwo | a0ef149fac0e566ef3f0298112e2031d344f2f97 | [
"BSD-2-Clause"
] | null | null | null | /*********************************************************************************
*
* Inviwo - Interactive Visualization Workshop
*
* Copyright (c) 2016-2020 Inviwo Foundation
* 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.
*
* 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 <modules/qtwidgets/qtwidgetssettings.h>
#include <modules/qtwidgets/inviwoqtutils.h>
#include <warn/push>
#include <warn/ignore/all>
#include <QFontDatabase>
#include <warn/pop>
namespace inviwo {
namespace {
std::vector<std::string> getMonoSpaceFonts() {
std::vector<std::string> fonts;
QFontDatabase fontdb;
for (auto& font : fontdb.families()) {
if (fontdb.isFixedPitch(font)) {
fonts.push_back(utilqt::fromQString(font));
}
}
return fonts;
}
size_t getDefaultFontIndex() {
const auto fonts = getMonoSpaceFonts();
const QFont fixedFont = QFontDatabase::systemFont(QFontDatabase::FixedFont);
auto it = std::find(fonts.begin(), fonts.end(), utilqt::fromQString(fixedFont.family()));
if (it != fonts.end()) {
return it - fonts.begin();
} else {
return 0;
}
}
#include <warn/push>
#include <warn/ignore/unused-variable>
const ivec4 ghost_white(248, 248, 240, 255);
const ivec4 light_ghost_white(248, 248, 242, 255);
const ivec4 light_gray(204, 204, 204, 255);
const ivec4 gray(136, 136, 136, 255);
const ivec4 brown_gray(73, 72, 62, 255);
const ivec4 dark_gray(43, 44, 39, 255);
const ivec4 yellow(230, 219, 116, 255);
const ivec4 blue(102, 217, 239, 255);
const ivec4 pink(249, 38, 114, 255);
const ivec4 purple(174, 129, 255, 255);
const ivec4 brown(117, 113, 94, 255);
const ivec4 orange(253, 151, 31, 255);
const ivec4 light_orange(255, 213, 105, 255);
const ivec4 green(166, 226, 46, 255);
const ivec4 sea_green(166, 228, 48, 255);
#include <warn/pop>
} // namespace
QtWidgetsSettings::QtWidgetsSettings()
: Settings("Syntax Highlighting")
, font_("font", "Font", getMonoSpaceFonts(), getDefaultFontIndex())
, fontSize_("fontSize", "Size", 11, 1, 72)
, glslSyntax_("glslSyntax", "GLSL Syntax Highlighting")
, glslTextColor_("glslTextColor", "Text", light_ghost_white, ivec4(0), ivec4(255), ivec4(1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslBackgroundColor_("glslBackgroundColor", "Background", dark_gray, ivec4(0), ivec4(255),
ivec4(1), InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslBackgroundHighLightColor_("glslBackgroundHighLightColor", "High Light",
ivec4{33, 34, 29, 255}, ivec4(0), ivec4(255), ivec4(1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslQualifierColor_("glslQualifierColor", "Qualifiers", pink, ivec4(0), ivec4(255), ivec4(1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslBuiltinsColor_("glslBultinsColor", "Builtins", orange, ivec4(0), ivec4(255), ivec4(1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslTypeColor_("glslTypeColor", "Types", blue, ivec4(0), ivec4(255), ivec4(1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslGlslBuiltinsColor_("glslGlslBultinsColor", "GLSL Builtins", blue, ivec4(0), ivec4(255),
ivec4(1), InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslCommentColor_("glslCommentColor", "Comments", gray, ivec4(0), ivec4(255), ivec4(1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslPreProcessorColor_("glslPreProcessorColor", "Pre Processor", pink, ivec4(0), ivec4(255),
ivec4(1), InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslConstantsColor_("glslConstantsColor", "Constants", purple, ivec4(0), ivec4(255), ivec4(1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslVoidMainColor_("glslVoidMainColor", "void main", sea_green, ivec4(0), ivec4(255),
ivec4(1), InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, pythonSyntax_("pythonSyntax", "Python Syntax Highlighting")
, pyBGColor_("pyBGColor", "Background", ivec4(0xb0, 0xb0, 0xbc, 255), ivec4(0), ivec4(255),
ivec4(1), InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, pyBGHighLightColor_("pyBGHighLightColor", "High Light", ivec4(0xd0, 0xd0, 0xdc, 255),
ivec4(0), ivec4(255), ivec4(1), InvalidationLevel::InvalidOutput,
PropertySemantics::Color)
, pyTextColor_("pyTextColor", "Text", ivec4(0x11, 0x11, 0x11, 255), ivec4(0), ivec4(255),
ivec4(1), InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, pyTypeColor_("pyTypeColor", "Types", ivec4(0x14, 0x3C, 0xA6, 255), ivec4(0), ivec4(255),
ivec4(1), InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, pyCommentsColor_("pyCommentsColor", "Comments", ivec4(0x00, 0x66, 0x00, 255), ivec4(0),
ivec4(255), ivec4(1), InvalidationLevel::InvalidOutput,
PropertySemantics::Color) {
addProperty(font_);
addProperty(fontSize_);
addProperty(glslSyntax_);
glslSyntax_.addProperty(glslBackgroundColor_);
glslSyntax_.addProperty(glslBackgroundHighLightColor_);
glslSyntax_.addProperty(glslTextColor_);
glslSyntax_.addProperty(glslCommentColor_);
glslSyntax_.addProperty(glslTypeColor_);
glslSyntax_.addProperty(glslQualifierColor_);
glslSyntax_.addProperty(glslBuiltinsColor_);
glslSyntax_.addProperty(glslGlslBuiltinsColor_);
glslSyntax_.addProperty(glslPreProcessorColor_);
glslSyntax_.addProperty(glslConstantsColor_);
glslSyntax_.addProperty(glslVoidMainColor_);
addProperty(pythonSyntax_);
pythonSyntax_.addProperty(pyBGColor_);
pythonSyntax_.addProperty(pyBGHighLightColor_);
pythonSyntax_.addProperty(pyTextColor_);
pythonSyntax_.addProperty(pyCommentsColor_);
pythonSyntax_.addProperty(pyTypeColor_);
load();
}
} // namespace inviwo
| 48.171975 | 100 | 0.681211 | tirpidz |
299dfc2582c7385750daa61987b30351807b0c75 | 1,514 | hpp | C++ | include/tnt/linear/impl/discrete_cosine_transform_impl.hpp | JordanCheney/tnt | a0fd378079d36b2bd39960c34e5c83f9633db0c0 | [
"MIT"
] | null | null | null | include/tnt/linear/impl/discrete_cosine_transform_impl.hpp | JordanCheney/tnt | a0fd378079d36b2bd39960c34e5c83f9633db0c0 | [
"MIT"
] | 1 | 2018-06-09T04:40:01.000Z | 2018-06-09T04:40:01.000Z | include/tnt/linear/impl/discrete_cosine_transform_impl.hpp | JordanCheney/tnt | a0fd378079d36b2bd39960c34e5c83f9633db0c0 | [
"MIT"
] | null | null | null | #ifndef TNT_LINEAR_DISCRETE_COSINE_TRANSFORM_IMPL_HPP
#define TNT_LINEAR_DISCRETE_COSINE_TRANSFORM_IMPL_HPP
#include <tnt/linear/discrete_cosine_transform.hpp>
#include <tnt/utils/testing.hpp>
#include <tnt/utils/simd.hpp>
namespace tnt
{
namespace detail
{
constexpr static int dct_forward_coeffs[64] = {
1, 1, 1, 1, 1, 1, 1, 1,
15, 101, 35, 1, -1, -35, -101, -15,
3, 1, -1, -3, -3, -1, 1, 3,
1, 3, -11, -1, 1, 11, -3, -1,
1, -1, -1, 1, 1, -1, -1, 1,
1, -23, -1, 1, -1, 1, 23, -1,
1, -1, 1, -1, -1, 1, -1, 1,
1, -21, 13, -1, 1, -13, 21, -1
};
constexpr static int dct_forward_shifts[64] = {
0, 0, 0, 0, 0, 0, 0, 0,
4, 7, 6, 2, 2, 6, 7, 4,
2, 1, 1, 2, 2, 1, 1, 2,
1, 5, 4, 1, 1, 4, 5, 1,
1, 1, 1, 1, 1, 1, 1, 1,
0, 4, 3, 0, 0, 3, 4, 0,
1, 0, 0, 1, 1, 0, 0, 1,
2, 5, 4, 0, 0, 4, 5, 2
};
template <typename DataType>
struct OptimizedDCT<DataType, void>
{
using VecType = typename SIMDType<DataType>::VecType;
static Tensor<DataType> eval(const Tensor<DataType>& tensor)
{
}
};
} // namespace detail
} // namespace tnt
#endif // TNT_LINEAR_DISCRETE_COSINE_TRANSFORM_IMPL_HPP
| 28.566038 | 64 | 0.437913 | JordanCheney |
299e10e3b23d88354c036e099fdf25bff771e74e | 813 | cpp | C++ | test2.cpp | birdhumming/usaco | f011e7bd4b71de22736a61004e501af2b273b246 | [
"OLDAP-2.2.1"
] | null | null | null | test2.cpp | birdhumming/usaco | f011e7bd4b71de22736a61004e501af2b273b246 | [
"OLDAP-2.2.1"
] | null | null | null | test2.cpp | birdhumming/usaco | f011e7bd4b71de22736a61004e501af2b273b246 | [
"OLDAP-2.2.1"
] | null | null | null | #include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
typedef unsigned long long ll;
typedef pair<int, int> ii;
const int N = 1010;
int n, g[N][N];
bool cows[N][N];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
int x, y; cin >> x >> y;
cows[x][y] = true;
for (int j = 0; j < 4; j++) {
int nx = x + dx[j];
int ny = y + dy[j];
if (nx >= 0 && nx <= 1000 && ny >= 0 && ny <= 1000) {
g[nx][ny]++;
if (cows[nx][ny] && g[nx][ny] == 3) ans++;
if (cows[nx][ny] && g[nx][ny] == 4) ans--;
}
}
if (g[x][y] == 3) ans++;
cout << ans << endl;
}
} | 22.583333 | 65 | 0.403444 | birdhumming |
299ff19dae424ffb3e837720712ea9bb0bdf9d47 | 66,157 | cpp | C++ | src/libawkward/array/RecordArray.cpp | HenryDayHall/awkward-1.0 | 4a860e775502f9adb953524c35c5a2de8f7a3181 | [
"BSD-3-Clause"
] | null | null | null | src/libawkward/array/RecordArray.cpp | HenryDayHall/awkward-1.0 | 4a860e775502f9adb953524c35c5a2de8f7a3181 | [
"BSD-3-Clause"
] | null | null | null | src/libawkward/array/RecordArray.cpp | HenryDayHall/awkward-1.0 | 4a860e775502f9adb953524c35c5a2de8f7a3181 | [
"BSD-3-Clause"
] | null | null | null | // BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
#define FILENAME(line) FILENAME_FOR_EXCEPTIONS("src/libawkward/array/RecordArray.cpp", line)
#define FILENAME_C(line) FILENAME_FOR_EXCEPTIONS_C("src/libawkward/array/RecordArray.cpp", line)
#include <sstream>
#include <algorithm>
#include "awkward/kernels.h"
#include "awkward/kernel-utils.h"
#include "awkward/type/RecordType.h"
#include "awkward/Reducer.h"
#include "awkward/array/Record.h"
#include "awkward/io/json.h"
#include "awkward/array/EmptyArray.h"
#include "awkward/array/IndexedArray.h"
#include "awkward/array/UnionArray.h"
#include "awkward/array/ByteMaskedArray.h"
#include "awkward/array/BitMaskedArray.h"
#include "awkward/array/UnmaskedArray.h"
#include "awkward/array/NumpyArray.h"
#include "awkward/array/VirtualArray.h"
#include "awkward/array/RecordArray.h"
namespace awkward {
////////// RecordForm
RecordForm::RecordForm(bool has_identities,
const util::Parameters& parameters,
const FormKey& form_key,
const util::RecordLookupPtr& recordlookup,
const std::vector<FormPtr>& contents)
: Form(has_identities, parameters, form_key)
, recordlookup_(recordlookup)
, contents_(contents) {
if (recordlookup.get() != nullptr &&
recordlookup.get()->size() != contents.size()) {
throw std::invalid_argument(
std::string("recordlookup (if provided) and contents must have the same length")
+ FILENAME(__LINE__));
}
}
const util::RecordLookupPtr
RecordForm::recordlookup() const {
return recordlookup_;
}
const std::vector<FormPtr>
RecordForm::contents() const {
return contents_;
}
bool
RecordForm::istuple() const {
return recordlookup_.get() == nullptr;
}
const FormPtr
RecordForm::content(int64_t fieldindex) const {
if (fieldindex >= numfields()) {
throw std::invalid_argument(
std::string("fieldindex ") + std::to_string(fieldindex)
+ std::string(" for record with only ") + std::to_string(numfields())
+ std::string(" fields") + FILENAME(__LINE__));
}
return contents_[(size_t)fieldindex];
}
const FormPtr
RecordForm::content(const std::string& key) const {
return contents_[(size_t)fieldindex(key)];
}
const std::vector<std::pair<std::string, FormPtr>>
RecordForm::items() const {
std::vector<std::pair<std::string, FormPtr>> out;
if (recordlookup_.get() != nullptr) {
size_t cols = contents_.size();
for (size_t j = 0; j < cols; j++) {
out.push_back(
std::pair<std::string, FormPtr>(recordlookup_.get()->at(j),
contents_[j]));
}
}
else {
size_t cols = contents_.size();
for (size_t j = 0; j < cols; j++) {
out.push_back(
std::pair<std::string, FormPtr>(std::to_string(j),
contents_[j]));
}
}
return out;
}
const TypePtr
RecordForm::type(const util::TypeStrs& typestrs) const {
std::vector<TypePtr> types;
for (auto item : contents_) {
types.push_back(item.get()->type(typestrs));
}
return std::make_shared<RecordType>(
parameters_,
util::gettypestr(parameters_, typestrs),
types,
recordlookup_);
}
void
RecordForm::tojson_part(ToJson& builder, bool verbose) const {
builder.beginrecord();
builder.field("class");
builder.string("RecordArray");
builder.field("contents");
if (recordlookup_.get() == nullptr) {
builder.beginlist();
for (auto x : contents_) {
x.get()->tojson_part(builder, verbose);
}
builder.endlist();
}
else {
builder.beginrecord();
for (size_t i = 0; i < recordlookup_.get()->size(); i++) {
builder.field(recordlookup_.get()->at(i));
contents_[i].get()->tojson_part(builder, verbose);
}
builder.endrecord();
}
identities_tojson(builder, verbose);
parameters_tojson(builder, verbose);
form_key_tojson(builder, verbose);
builder.endrecord();
}
const FormPtr
RecordForm::shallow_copy() const {
return std::make_shared<RecordForm>(has_identities_,
parameters_,
form_key_,
recordlookup_,
contents_);
}
const FormPtr
RecordForm::with_form_key(const FormKey& form_key) const {
return std::make_shared<RecordForm>(has_identities_,
parameters_,
form_key,
recordlookup_,
contents_);
}
const std::string
RecordForm::purelist_parameter(const std::string& key) const {
return parameter(key);
}
bool
RecordForm::purelist_isregular() const {
return true;
}
int64_t
RecordForm::purelist_depth() const {
return 1;
}
bool
RecordForm::dimension_optiontype() const {
return false;
}
const std::pair<int64_t, int64_t>
RecordForm::minmax_depth() const {
if (contents_.empty()) {
return std::pair<int64_t, int64_t>(0, 0);
}
int64_t min = kMaxInt64;
int64_t max = 0;
for (auto content : contents_) {
std::pair<int64_t, int64_t> minmax = content.get()->minmax_depth();
if (minmax.first < min) {
min = minmax.first;
}
if (minmax.second > max) {
max = minmax.second;
}
}
return std::pair<int64_t, int64_t>(min, max);
}
const std::pair<bool, int64_t>
RecordForm::branch_depth() const {
if (contents_.empty()) {
return std::pair<bool, int64_t>(false, 1);
}
else {
bool anybranch = false;
int64_t mindepth = -1;
for (auto content : contents_) {
std::pair<bool, int64_t> content_depth = content.get()->branch_depth();
if (mindepth == -1) {
mindepth = content_depth.second;
}
if (content_depth.first || mindepth != content_depth.second) {
anybranch = true;
}
if (mindepth > content_depth.second) {
mindepth = content_depth.second;
}
}
return std::pair<bool, int64_t>(anybranch, mindepth);
}
}
int64_t
RecordForm::numfields() const {
return (int64_t)contents_.size();
}
int64_t
RecordForm::fieldindex(const std::string& key) const {
return util::fieldindex(recordlookup_, key, numfields());
}
const std::string
RecordForm::key(int64_t fieldindex) const {
return util::key(recordlookup_, fieldindex, numfields());
}
bool
RecordForm::haskey(const std::string& key) const {
return util::haskey(recordlookup_, key, numfields());
}
const std::vector<std::string>
RecordForm::keys() const {
return util::keys(recordlookup_, numfields());
}
bool
RecordForm::equal(const FormPtr& other,
bool check_identities,
bool check_parameters,
bool check_form_key,
bool compatibility_check) const {
if (compatibility_check) {
if (VirtualForm* raw = dynamic_cast<VirtualForm*>(other.get())) {
if (raw->form().get() != nullptr) {
return equal(raw->form(),
check_identities,
check_parameters,
check_form_key,
compatibility_check);
}
}
}
if (check_identities &&
has_identities_ != other.get()->has_identities()) {
return false;
}
if (check_parameters &&
!util::parameters_equal(parameters_, other.get()->parameters(), false)) {
return false;
}
if (check_form_key &&
!form_key_equals(other.get()->form_key())) {
return false;
}
if (RecordForm* t = dynamic_cast<RecordForm*>(other.get())) {
if (recordlookup_.get() == nullptr &&
t->recordlookup().get() != nullptr) {
return false;
}
else if (recordlookup_.get() != nullptr &&
t->recordlookup().get() == nullptr) {
return false;
}
else if (recordlookup_.get() != nullptr &&
t->recordlookup().get() != nullptr) {
util::RecordLookupPtr one = recordlookup_;
util::RecordLookupPtr two = t->recordlookup();
if (one.get()->size() != two.get()->size()) {
return false;
}
for (int64_t i = 0; i < (int64_t)one.get()->size(); i++) {
int64_t j = 0;
for (; j < (int64_t)one.get()->size(); j++) {
if (one.get()->at((uint64_t)i) == two.get()->at((uint64_t)j)) {
break;
}
}
if (j == (int64_t)one.get()->size()) {
return false;
}
if (!content(i).get()->equal(t->content(j),
check_identities,
check_parameters,
check_form_key,
compatibility_check)) {
return false;
}
}
return true;
}
else {
if (numfields() != t->numfields()) {
return false;
}
for (int64_t i = 0; i < numfields(); i++) {
if (!content(i).get()->equal(t->content(i),
check_identities,
check_parameters,
check_form_key,
compatibility_check)) {
return false;
}
}
return true;
}
}
else {
return false;
}
}
const FormPtr
RecordForm::getitem_field(const std::string& key) const {
return content(key);
}
const FormPtr
RecordForm::getitem_fields(const std::vector<std::string>& keys) const {
util::RecordLookupPtr recordlookup(nullptr);
if (recordlookup_.get() != nullptr) {
recordlookup = std::make_shared<util::RecordLookup>();
}
std::vector<FormPtr> contents;
for (auto key : keys) {
if (recordlookup_.get() != nullptr) {
recordlookup.get()->push_back(key);
}
contents.push_back(contents_[(size_t)fieldindex(key)]);
}
return std::make_shared<RecordForm>(has_identities_,
util::Parameters(),
FormKey(nullptr),
recordlookup,
contents);
}
////////// RecordArray
RecordArray::RecordArray(const IdentitiesPtr& identities,
const util::Parameters& parameters,
const ContentPtrVec& contents,
const util::RecordLookupPtr& recordlookup,
int64_t length,
const std::vector<ArrayCachePtr>& caches)
: Content(identities, parameters)
, contents_(contents)
, recordlookup_(recordlookup)
, length_(length)
, caches_(caches) {
if (recordlookup_.get() != nullptr &&
recordlookup_.get()->size() != contents_.size()) {
throw std::invalid_argument(
std::string("recordlookup and contents must have the same number of fields")
+ FILENAME(__LINE__));
}
}
const std::vector<ArrayCachePtr>
fillcache(const ContentPtrVec& contents) {
std::vector<ArrayCachePtr> out;
for (auto content : contents) {
content.get()->caches(out);
}
return out;
}
RecordArray::RecordArray(const IdentitiesPtr& identities,
const util::Parameters& parameters,
const ContentPtrVec& contents,
const util::RecordLookupPtr& recordlookup,
int64_t length)
: Content(identities, parameters)
, contents_(contents)
, recordlookup_(recordlookup)
, length_(length)
, caches_(fillcache(contents)) { }
int64_t
minlength(const ContentPtrVec& contents) {
if (contents.empty()) {
return 0;
}
else {
int64_t out = -1;
for (auto x : contents) {
int64_t len = x.get()->length();
if (out < 0 || out > len) {
out = len;
}
}
return out;
}
}
RecordArray::RecordArray(const IdentitiesPtr& identities,
const util::Parameters& parameters,
const ContentPtrVec& contents,
const util::RecordLookupPtr& recordlookup)
: RecordArray(identities,
parameters,
contents,
recordlookup,
minlength(contents)) { }
const ContentPtrVec
RecordArray::contents() const {
return contents_;
}
const util::RecordLookupPtr
RecordArray::recordlookup() const {
return recordlookup_;
}
bool
RecordArray::istuple() const {
return recordlookup_.get() == nullptr;
}
const ContentPtr
RecordArray::setitem_field(int64_t where, const ContentPtr& what) const {
if (where < 0) {
throw std::invalid_argument(
std::string("where must be non-negative") + FILENAME(__LINE__));
}
if (what.get()->length() != length()) {
throw std::invalid_argument(
std::string("array of length ") + std::to_string(what.get()->length())
+ std::string(" cannot be assigned to record array of length ")
+ std::to_string(length()) + FILENAME(__LINE__));
}
ContentPtrVec contents;
for (size_t i = 0; i < contents_.size(); i++) {
if (where == (int64_t)i) {
contents.push_back(what);
}
contents.push_back(contents_[i]);
}
if (where >= numfields()) {
contents.push_back(what);
}
util::RecordLookupPtr recordlookup(nullptr);
if (recordlookup_.get() != nullptr) {
recordlookup = std::make_shared<util::RecordLookup>();
for (size_t i = 0; i < contents_.size(); i++) {
if (where == (int64_t)i) {
recordlookup.get()->push_back(std::to_string(where));
}
recordlookup.get()->push_back(recordlookup_.get()->at(i));
}
if (where >= numfields()) {
recordlookup.get()->push_back(std::to_string(where));
}
}
std::vector<ArrayCachePtr> caches(caches_);
what.get()->caches(caches);
return std::make_shared<RecordArray>(identities_,
parameters_,
contents,
recordlookup,
minlength(contents),
caches);
}
const ContentPtr
RecordArray::setitem_field(const std::string& where,
const ContentPtr& what) const {
if (what.get()->length() != length()) {
throw std::invalid_argument(
std::string("array of length ") + std::to_string(what.get()->length())
+ std::string(" cannot be assigned to record array of length ")
+ std::to_string(length()) + FILENAME(__LINE__));
}
ContentPtrVec contents(contents_.begin(), contents_.end());
contents.push_back(what);
util::RecordLookupPtr recordlookup;
if (recordlookup_.get() != nullptr) {
recordlookup = std::make_shared<util::RecordLookup>();
recordlookup.get()->insert(recordlookup.get()->end(),
recordlookup_.get()->begin(),
recordlookup_.get()->end());
recordlookup.get()->push_back(where);
}
else {
recordlookup = util::init_recordlookup(numfields());
recordlookup.get()->push_back(where);
}
std::vector<ArrayCachePtr> caches(caches_);
what.get()->caches(caches);
return std::make_shared<RecordArray>(identities_,
parameters_,
contents,
recordlookup,
minlength(contents),
caches);
}
const std::string
RecordArray::classname() const {
return "RecordArray";
}
void
RecordArray::setidentities() {
int64_t len = length();
if (len <= kMaxInt32) {
IdentitiesPtr newidentities =
std::make_shared<Identities32>(Identities::newref(),
Identities::FieldLoc(),
1,
len);
Identities32* rawidentities =
reinterpret_cast<Identities32*>(newidentities.get());
struct Error err = kernel::new_Identities<int32_t>(
kernel::lib::cpu, // DERIVE
rawidentities->data(),
len);
util::handle_error(err, classname(), identities_.get());
setidentities(newidentities);
}
else {
IdentitiesPtr newidentities =
std::make_shared<Identities64>(Identities::newref(),
Identities::FieldLoc(),
1, len);
Identities64* rawidentities =
reinterpret_cast<Identities64*>(newidentities.get());
struct Error err = kernel::new_Identities<int64_t>(
kernel::lib::cpu, // DERIVE
rawidentities->data(),
len);
util::handle_error(err, classname(), identities_.get());
setidentities(newidentities);
}
}
void
RecordArray::setidentities(const IdentitiesPtr& identities) {
if (identities.get() == nullptr) {
for (auto content : contents_) {
content.get()->setidentities(identities);
}
}
else {
if (length() != identities.get()->length()) {
util::handle_error(
failure("content and its identities must have the same length",
kSliceNone,
kSliceNone,
FILENAME_C(__LINE__)),
classname(),
identities_.get());
}
if (istuple()) {
Identities::FieldLoc original = identities.get()->fieldloc();
for (size_t j = 0; j < contents_.size(); j++) {
Identities::FieldLoc fieldloc(original.begin(), original.end());
fieldloc.push_back(
std::pair<int64_t, std::string>(identities.get()->width() - 1,
std::to_string(j)));
contents_[j].get()->setidentities(
identities.get()->withfieldloc(fieldloc));
}
}
else {
Identities::FieldLoc original = identities.get()->fieldloc();
for (size_t j = 0; j < contents_.size(); j++) {
Identities::FieldLoc fieldloc(original.begin(), original.end());
fieldloc.push_back(std::pair<int64_t, std::string>(
identities.get()->width() - 1, recordlookup_.get()->at(j)));
contents_[j].get()->setidentities(
identities.get()->withfieldloc(fieldloc));
}
}
}
identities_ = identities;
}
const TypePtr
RecordArray::type(const util::TypeStrs& typestrs) const {
return form(true).get()->type(typestrs);
}
const FormPtr
RecordArray::form(bool materialize) const {
std::vector<FormPtr> contents;
for (auto x : contents_) {
contents.push_back(x.get()->form(materialize));
}
return std::make_shared<RecordForm>(identities_.get() != nullptr,
parameters_,
FormKey(nullptr),
recordlookup_,
contents);
}
kernel::lib
RecordArray::kernels() const {
kernel::lib last = kernel::lib::size;
for (auto content : contents_) {
if (last == kernel::lib::size) {
last = content.get()->kernels();
}
else if (last != content.get()->kernels()) {
return kernel::lib::size;
}
}
if (identities_.get() == nullptr) {
if (last == kernel::lib::size) {
return kernel::lib::cpu;
}
else {
return last;
}
}
else {
if (last == kernel::lib::size) {
return identities_.get()->ptr_lib();
}
else if (last == identities_.get()->ptr_lib()) {
return last;
}
else {
return kernel::lib::size;
}
}
}
void
RecordArray::caches(std::vector<ArrayCachePtr>& out) const {
out.insert(out.end(), caches_.begin(), caches_.end());
}
const std::string
RecordArray::tostring_part(const std::string& indent,
const std::string& pre,
const std::string& post) const {
std::stringstream out;
out << indent << pre << "<" << classname() << " length=\"" << length_ << "\"";
out << ">\n";
if (identities_.get() != nullptr) {
out << identities_.get()->tostring_part(
indent + std::string(" "), "", "\n");
}
if (!parameters_.empty()) {
out << parameters_tostring(indent + std::string(" "), "", "\n");
}
for (size_t j = 0; j < contents_.size(); j++) {
out << indent << " <field index=\"" << j << "\"";
if (!istuple()) {
out << " key=\"" << recordlookup_.get()->at(j) << "\">";
}
else {
out << ">";
}
out << "\n";
out << contents_[j].get()->tostring_part(
indent + std::string(" "), "", "\n");
out << indent << " </field>\n";
}
out << indent << "</" << classname() << ">" << post;
return out.str();
}
void
RecordArray::tojson_part(ToJson& builder, bool include_beginendlist) const {
int64_t rows = length();
size_t cols = contents_.size();
util::RecordLookupPtr keys = recordlookup_;
if (istuple()) {
keys = std::make_shared<util::RecordLookup>();
for (size_t j = 0; j < cols; j++) {
keys.get()->push_back(std::to_string(j));
}
}
check_for_iteration();
if (include_beginendlist) {
builder.beginlist();
}
for (int64_t i = 0; i < rows; i++) {
builder.beginrecord();
for (size_t j = 0; j < cols; j++) {
builder.field(keys.get()->at(j).c_str());
contents_[j].get()->getitem_at_nowrap(i).get()->tojson_part(builder,
true);
}
builder.endrecord();
}
if (include_beginendlist) {
builder.endlist();
}
}
void
RecordArray::nbytes_part(std::map<size_t, int64_t>& largest) const {
for (auto x : contents_) {
x.get()->nbytes_part(largest);
}
if (identities_.get() != nullptr) {
identities_.get()->nbytes_part(largest);
}
}
int64_t
RecordArray::length() const {
return length_;
}
const ContentPtr
RecordArray::shallow_copy() const {
return std::make_shared<RecordArray>(identities_,
parameters_,
contents_,
recordlookup_,
length_,
caches_);
}
const ContentPtr
RecordArray::deep_copy(bool copyarrays,
bool copyindexes,
bool copyidentities) const {
ContentPtrVec contents;
for (auto x : contents_) {
contents.push_back(x.get()->deep_copy(copyarrays,
copyindexes,
copyidentities));
}
IdentitiesPtr identities = identities_;
if (copyidentities && identities_.get() != nullptr) {
identities = identities_.get()->deep_copy();
}
return std::make_shared<RecordArray>(identities,
parameters_,
contents,
recordlookup_,
length_,
caches_);
}
void
RecordArray::check_for_iteration() const {
if (identities_.get() != nullptr &&
identities_.get()->length() < length()) {
util::handle_error(
failure("len(identities) < len(array)",
kSliceNone,
kSliceNone,
FILENAME_C(__LINE__)),
identities_.get()->classname(),
nullptr);
}
}
const ContentPtr
RecordArray::getitem_nothing() const {
return getitem_range_nowrap(0, 0);
}
const ContentPtr
RecordArray::getitem_at(int64_t at) const {
int64_t regular_at = at;
int64_t len = length();
if (regular_at < 0) {
regular_at += len;
}
if (!(0 <= regular_at && regular_at < len)) {
util::handle_error(
failure("index out of range",
kSliceNone,
at,
FILENAME_C(__LINE__)),
classname(),
identities_.get());
}
return getitem_at_nowrap(regular_at);
}
const ContentPtr
RecordArray::getitem_at_nowrap(int64_t at) const {
return std::make_shared<Record>(shared_from_this(), at);
}
const ContentPtr
RecordArray::getitem_range(int64_t start, int64_t stop) const {
int64_t regular_start = start;
int64_t regular_stop = stop;
kernel::regularize_rangeslice(®ular_start, ®ular_stop,
true, start != Slice::none(), stop != Slice::none(), length_);
if (identities_.get() != nullptr &&
regular_stop > identities_.get()->length()) {
util::handle_error(
failure("index out of range",
kSliceNone,
stop,
FILENAME_C(__LINE__)),
identities_.get()->classname(),
nullptr);
}
return getitem_range_nowrap(regular_start, regular_stop);
}
const ContentPtr
RecordArray::getitem_range_nowrap(int64_t start, int64_t stop) const {
IdentitiesPtr identities(nullptr);
if (identities_.get() != nullptr) {
identities = identities_.get()->getitem_range_nowrap(start, stop);
}
if (contents_.empty()) {
return std::make_shared<RecordArray>(identities,
parameters_,
contents_,
recordlookup_,
stop - start,
caches_);
}
else if (start == 0 && stop == length_) {
return shallow_copy();
}
else {
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(content.get()->getitem_range_nowrap(start, stop));
}
return std::make_shared<RecordArray>(identities,
parameters_,
contents,
recordlookup_,
stop - start,
caches_);
}
}
const ContentPtr
RecordArray::getitem_field(const std::string& key) const {
return field(key).get()->getitem_range_nowrap(0, length());
}
const ContentPtr
RecordArray::getitem_field(const std::string& key,
const Slice& only_fields) const {
SliceItemPtr nexthead = only_fields.head();
Slice nexttail = only_fields.tail();
ContentPtr next = field(key).get()->getitem_range_nowrap(0, length());
if (SliceField* raw = dynamic_cast<SliceField*>(nexthead.get())) {
next = next.get()->getitem_field(raw->key(), nexttail);
}
else if (SliceFields* raw = dynamic_cast<SliceFields*>(nexthead.get())) {
next = next.get()->getitem_fields(raw->keys(), nexttail);
}
return next;
}
const ContentPtr
RecordArray::getitem_fields(const std::vector<std::string>& keys) const {
ContentPtrVec contents;
util::RecordLookupPtr recordlookup(nullptr);
if (recordlookup_.get() != nullptr) {
recordlookup = std::make_shared<util::RecordLookup>();
}
for (auto key : keys) {
contents.push_back(field(key));
if (recordlookup.get() != nullptr) {
recordlookup.get()->push_back(key);
}
}
return std::make_shared<RecordArray>(identities_,
util::Parameters(),
contents,
recordlookup,
length_,
caches_);
}
const ContentPtr
RecordArray::getitem_fields(const std::vector<std::string>& keys,
const Slice& only_fields) const {
SliceItemPtr nexthead = only_fields.head();
Slice nexttail = only_fields.tail();
ContentPtrVec contents;
util::RecordLookupPtr recordlookup(nullptr);
if (recordlookup_.get() != nullptr) {
recordlookup = std::make_shared<util::RecordLookup>();
}
for (auto key : keys) {
ContentPtr next = field(key);
if (SliceField* raw = dynamic_cast<SliceField*>(nexthead.get())) {
next = next.get()->getitem_field(raw->key(), nexttail);
}
else if (SliceFields* raw = dynamic_cast<SliceFields*>(nexthead.get())) {
next = next.get()->getitem_fields(raw->keys(), nexttail);
}
contents.push_back(next);
if (recordlookup.get() != nullptr) {
recordlookup.get()->push_back(key);
}
}
return std::make_shared<RecordArray>(identities_,
util::Parameters(),
contents,
recordlookup,
length_,
caches_);
}
const ContentPtr
RecordArray::carry(const Index64& carry, bool allow_lazy) const {
if (!allow_lazy && carry.iscontiguous()) {
if (carry.length() == length()) {
return shallow_copy();
}
else {
return getitem_range_nowrap(0, carry.length());
}
}
IdentitiesPtr identities(nullptr);
if (identities_.get() != nullptr) {
identities = identities_.get()->getitem_carry_64(carry);
}
if (allow_lazy) {
return std::make_shared<IndexedArray64>(identities,
util::Parameters(),
carry,
shallow_copy());
}
else {
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(content.get()->carry(carry, allow_lazy));
}
return std::make_shared<RecordArray>(identities,
parameters_,
contents,
recordlookup_,
carry.length(),
caches_);
}
}
int64_t
RecordArray::purelist_depth() const {
return 1;
}
const std::pair<int64_t, int64_t>
RecordArray::minmax_depth() const {
if (contents_.empty()) {
return std::pair<int64_t, int64_t>(0, 0);
}
int64_t min = kMaxInt64;
int64_t max = 0;
for (auto content : contents_) {
std::pair<int64_t, int64_t> minmax = content.get()->minmax_depth();
if (minmax.first < min) {
min = minmax.first;
}
if (minmax.second > max) {
max = minmax.second;
}
}
return std::pair<int64_t, int64_t>(min, max);
}
const std::pair<bool, int64_t>
RecordArray::branch_depth() const {
if (contents_.empty()) {
return std::pair<bool, int64_t>(false, 1);
}
else {
bool anybranch = false;
int64_t mindepth = -1;
for (auto content : contents_) {
std::pair<bool, int64_t> content_depth = content.get()->branch_depth();
if (mindepth == -1) {
mindepth = content_depth.second;
}
if (content_depth.first || mindepth != content_depth.second) {
anybranch = true;
}
if (mindepth > content_depth.second) {
mindepth = content_depth.second;
}
}
return std::pair<bool, int64_t>(anybranch, mindepth);
}
}
int64_t
RecordArray::numfields() const {
return (int64_t)contents_.size();
}
int64_t
RecordArray::fieldindex(const std::string& key) const {
return util::fieldindex(recordlookup_, key, numfields());
}
const std::string
RecordArray::key(int64_t fieldindex) const {
return util::key(recordlookup_, fieldindex, numfields());
}
bool
RecordArray::haskey(const std::string& key) const {
return util::haskey(recordlookup_, key, numfields());
}
const std::vector<std::string>
RecordArray::keys() const {
return util::keys(recordlookup_, numfields());
}
const std::string
RecordArray::validityerror(const std::string& path) const {
const std::string paramcheck = validityerror_parameters(path);
if (paramcheck != std::string("")) {
return paramcheck;
}
for (int64_t i = 0; i < numfields(); i++) {
if (field(i).get()->length() < length_) {
return (std::string("at ") + path + std::string(" (") + classname()
+ std::string("): len(field(")
+ std::to_string(i) + (")) < len(recordarray)")
+ FILENAME(__LINE__));
}
}
for (int64_t i = 0; i < numfields(); i++) {
std::string sub = field(i).get()->validityerror(
path + std::string(".field(") + std::to_string(i) + (")"));
if (!sub.empty()) {
return sub;
}
}
return std::string();
}
const ContentPtr
RecordArray::shallow_simplify() const {
return shallow_copy();
}
const ContentPtr
RecordArray::num(int64_t axis, int64_t depth) const {
int64_t posaxis = axis_wrap_if_negative(axis);
if (posaxis == depth) {
Index64 single(1);
single.setitem_at_nowrap(0, length_);
ContentPtr singleton = std::make_shared<NumpyArray>(single);
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(singleton);
}
std::vector<ArrayCachePtr> caches;
ContentPtr record = std::make_shared<RecordArray>(Identities::none(),
util::Parameters(),
contents,
recordlookup_,
1,
caches);
return record.get()->getitem_at_nowrap(0);
}
else {
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(content.get()->num(posaxis, depth));
}
return std::make_shared<RecordArray>(Identities::none(),
util::Parameters(),
contents,
recordlookup_,
length_);
}
}
const std::pair<Index64, ContentPtr>
RecordArray::offsets_and_flattened(int64_t axis, int64_t depth) const {
int64_t posaxis = axis_wrap_if_negative(axis);
if (posaxis == depth) {
throw std::invalid_argument(
std::string("axis=0 not allowed for flatten") + FILENAME(__LINE__));
}
else if (posaxis == depth + 1) {
throw std::invalid_argument(
std::string("arrays of records cannot be flattened (but their contents can be; "
"try a different 'axis')") + FILENAME(__LINE__));
}
else {
ContentPtrVec contents;
for (auto content : contents_) {
ContentPtr trimmed = content.get()->getitem_range(0, length());
std::pair<Index64, ContentPtr> pair =
trimmed.get()->offsets_and_flattened(posaxis, depth);
if (pair.first.length() != 0) {
throw std::runtime_error(
std::string("RecordArray content with axis > depth + 1 returned a non-empty "
"offsets from offsets_and_flattened") + FILENAME(__LINE__));
}
contents.push_back(pair.second);
}
return std::pair<Index64, ContentPtr>(
Index64(0),
std::make_shared<RecordArray>(Identities::none(),
util::Parameters(),
contents,
recordlookup_));
}
}
bool
RecordArray::mergeable(const ContentPtr& other, bool mergebool) const {
if (VirtualArray* raw = dynamic_cast<VirtualArray*>(other.get())) {
return mergeable(raw->array(), mergebool);
}
if (!parameters_equal(other.get()->parameters(), false)) {
return false;
}
if (dynamic_cast<EmptyArray*>(other.get()) ||
dynamic_cast<UnionArray8_32*>(other.get()) ||
dynamic_cast<UnionArray8_U32*>(other.get()) ||
dynamic_cast<UnionArray8_64*>(other.get())) {
return true;
}
else if (IndexedArray32* rawother =
dynamic_cast<IndexedArray32*>(other.get())) {
return mergeable(rawother->content(), mergebool);
}
else if (IndexedArrayU32* rawother =
dynamic_cast<IndexedArrayU32*>(other.get())) {
return mergeable(rawother->content(), mergebool);
}
else if (IndexedArray64* rawother =
dynamic_cast<IndexedArray64*>(other.get())) {
return mergeable(rawother->content(), mergebool);
}
else if (IndexedOptionArray32* rawother =
dynamic_cast<IndexedOptionArray32*>(other.get())) {
return mergeable(rawother->content(), mergebool);
}
else if (IndexedOptionArray64* rawother =
dynamic_cast<IndexedOptionArray64*>(other.get())) {
return mergeable(rawother->content(), mergebool);
}
else if (ByteMaskedArray* rawother =
dynamic_cast<ByteMaskedArray*>(other.get())) {
return mergeable(rawother->content(), mergebool);
}
else if (BitMaskedArray* rawother =
dynamic_cast<BitMaskedArray*>(other.get())) {
return mergeable(rawother->content(), mergebool);
}
else if (UnmaskedArray* rawother =
dynamic_cast<UnmaskedArray*>(other.get())) {
return mergeable(rawother->content(), mergebool);
}
if (RecordArray* rawother =
dynamic_cast<RecordArray*>(other.get())) {
if (istuple() && rawother->istuple()) {
if (numfields() == rawother->numfields()) {
for (int64_t i = 0; i < numfields(); i++) {
if (!field(i).get()->mergeable(rawother->field(i), mergebool)) {
return false;
}
}
return true;
}
}
else if (!istuple() && !rawother->istuple()) {
std::vector<std::string> self_keys = keys();
std::vector<std::string> other_keys = rawother->keys();
std::sort(self_keys.begin(), self_keys.end());
std::sort(other_keys.begin(), other_keys.end());
if (self_keys == other_keys) {
for (auto key : self_keys) {
if (!field(key).get()->mergeable(rawother->field(key),
mergebool)) {
return false;
}
}
return true;
}
}
return false;
}
else {
return false;
}
}
bool
RecordArray::referentially_equal(const ContentPtr& other) const {
if (identities_.get() == nullptr && other.get()->identities().get() != nullptr) {
return false;
}
if (identities_.get() != nullptr && other.get()->identities().get() == nullptr) {
return false;
}
if (identities_.get() != nullptr && other.get()->identities().get() != nullptr) {
if (!identities_.get()->referentially_equal(other->identities())) {
return false;
}
}
if (RecordArray* raw = dynamic_cast<RecordArray*>(other.get())) {
if (length_ != raw->length() ||
parameters_ != raw->parameters()) {
return false;
}
if (recordlookup_.get() == nullptr && raw->recordlookup().get() != nullptr) {
return false;
}
if (recordlookup_.get() != nullptr && raw->recordlookup().get() == nullptr) {
return false;
}
if (recordlookup_.get() != nullptr && raw->recordlookup().get() != nullptr) {
if (recordlookup_.get() != raw->recordlookup().get()) {
return false;
}
}
if (numfields() != raw->numfields()) {
return false;
}
for (int64_t i = 0; i < numfields(); i++) {
if (!field(i).get()->referentially_equal(raw->field(i))) {
return false;
}
}
return true;
}
else {
return false;
}
}
const ContentPtr
RecordArray::mergemany(const ContentPtrVec& others) const {
if (others.empty()) {
return shallow_copy();
}
std::pair<ContentPtrVec, ContentPtrVec> head_tail = merging_strategy(others);
ContentPtrVec head = head_tail.first;
ContentPtrVec tail = head_tail.second;
util::Parameters parameters(parameters_);
ContentPtrVec headless(head.begin() + 1, head.end());
std::vector<ContentPtrVec> for_each_field;
for (auto field : contents_) {
ContentPtr trimmed = field.get()->getitem_range_nowrap(0, length_);
for_each_field.push_back(ContentPtrVec({ field }));
}
if (istuple()) {
for (auto array : headless) {
util::merge_parameters(parameters, array.get()->parameters());
if (VirtualArray* raw = dynamic_cast<VirtualArray*>(array.get())) {
array = raw->array();
}
if (RecordArray* raw = dynamic_cast<RecordArray*>(array.get())) {
if (istuple()) {
if (numfields() == raw->numfields()) {
for (size_t i = 0; i < contents_.size(); i++) {
ContentPtr field = raw->field((int64_t)i);
for_each_field[i].push_back(field.get()->getitem_range_nowrap(0, raw->length()));
}
}
else {
throw std::invalid_argument(
std::string("cannot merge tuples with different numbers of fields")
+ FILENAME(__LINE__));
}
}
else {
throw std::invalid_argument(
std::string("cannot merge tuple with non-tuple record")
+ FILENAME(__LINE__));
}
}
else if (EmptyArray* raw = dynamic_cast<EmptyArray*>(array.get())) {
;
}
else {
throw std::invalid_argument(
std::string("cannot merge ") + classname() + std::string(" with ")
+ array.get()->classname() + FILENAME(__LINE__));
}
}
}
else {
std::vector<std::string> these_keys = keys();
std::sort(these_keys.begin(), these_keys.end());
for (auto array : headless) {
if (VirtualArray* raw = dynamic_cast<VirtualArray*>(array.get())) {
array = raw->array();
}
if (RecordArray* raw = dynamic_cast<RecordArray*>(array.get())) {
if (!istuple()) {
std::vector<std::string> those_keys = raw->keys();
std::sort(those_keys.begin(), those_keys.end());
if (these_keys == those_keys) {
for (size_t i = 0; i < contents_.size(); i++) {
ContentPtr field = raw->field(key((int64_t)i));
ContentPtr trimmed = field.get()->getitem_range_nowrap(0, raw->length());
for_each_field[i].push_back(trimmed);
}
}
else {
throw std::invalid_argument(
std::string("cannot merge records with different sets of field names")
+ FILENAME(__LINE__));
}
}
else {
throw std::invalid_argument(
std::string("cannot merge non-tuple record with tuple")
+ FILENAME(__LINE__));
}
}
else if (EmptyArray* raw = dynamic_cast<EmptyArray*>(array.get())) {
;
}
else {
throw std::invalid_argument(
std::string("cannot merge ") + classname() + std::string(" with ")
+ array.get()->classname() + FILENAME(__LINE__));
}
}
}
ContentPtrVec nextcontents;
int64_t minlength = -1;
for (auto forfield : for_each_field) {
ContentPtrVec tail_forfield(forfield.begin() + 1, forfield.end());
ContentPtr merged = forfield[0].get()->mergemany(tail_forfield);
nextcontents.push_back(merged);
if (minlength == -1 || merged.get()->length() < minlength) {
minlength = merged.get()->length();
}
}
ContentPtr next = std::make_shared<RecordArray>(Identities::none(),
parameters,
nextcontents,
recordlookup_,
minlength);
if (tail.empty()) {
return next;
}
ContentPtr reversed = tail[0].get()->reverse_merge(next);
if (tail.size() == 1) {
return reversed;
}
else {
return reversed.get()->mergemany(ContentPtrVec(tail.begin() + 1, tail.end()));
}
}
const SliceItemPtr
RecordArray::asslice() const {
throw std::invalid_argument(
std::string("cannot use records as a slice") + FILENAME(__LINE__));
}
const ContentPtr
RecordArray::fillna(const ContentPtr& value) const {
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(content.get()->fillna(value));
}
return std::make_shared<RecordArray>(identities_,
parameters_,
contents,
recordlookup_,
length_);
}
const ContentPtr
RecordArray::rpad(int64_t target, int64_t axis, int64_t depth) const {
int64_t posaxis = axis_wrap_if_negative(axis);
if (posaxis == depth) {
return rpad_axis0(target, false);
}
else {
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(content.get()->rpad(target, posaxis, depth));
}
if (contents.empty()) {
return std::make_shared<RecordArray>(identities_,
parameters_,
contents,
recordlookup_,
length_);
}
else {
return std::make_shared<RecordArray>(identities_,
parameters_,
contents,
recordlookup_);
}
}
}
const ContentPtr
RecordArray::rpad_and_clip(int64_t target,
int64_t axis,
int64_t depth) const {
int64_t posaxis = axis_wrap_if_negative(axis);
if (posaxis == depth) {
return rpad_axis0(target, true);
}
else {
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(
content.get()->rpad_and_clip(target, posaxis, depth));
}
if (contents.empty()) {
return std::make_shared<RecordArray>(identities_,
parameters_,
contents,
recordlookup_,
length_);
}
else {
return std::make_shared<RecordArray>(identities_,
parameters_,
contents,
recordlookup_);
}
}
}
const ContentPtr
RecordArray::reduce_next(const Reducer& reducer,
int64_t negaxis,
const Index64& starts,
const Index64& shifts,
const Index64& parents,
int64_t outlength,
bool mask,
bool keepdims) const {
ContentPtrVec contents;
for (auto content : contents_) {
ContentPtr trimmed = content.get()->getitem_range_nowrap(0, length());
ContentPtr next = trimmed.get()->reduce_next(reducer,
negaxis,
starts,
shifts,
parents,
outlength,
mask,
keepdims);
contents.push_back(next);
}
return std::make_shared<RecordArray>(Identities::none(),
util::Parameters(),
contents,
recordlookup_,
outlength);
}
const ContentPtr
RecordArray::localindex(int64_t axis, int64_t depth) const {
int64_t posaxis = axis_wrap_if_negative(axis);
if (posaxis == depth) {
return localindex_axis0();
}
else {
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(content.get()->localindex(posaxis, depth));
}
return std::make_shared<RecordArray>(identities_,
util::Parameters(),
contents,
recordlookup_,
length_);
}
}
const ContentPtr
RecordArray::combinations(int64_t n,
bool replacement,
const util::RecordLookupPtr& recordlookup,
const util::Parameters& parameters,
int64_t axis,
int64_t depth) const {
if (n < 1) {
throw std::invalid_argument(
std::string("in combinations, 'n' must be at least 1") + FILENAME(__LINE__));
}
int64_t posaxis = axis_wrap_if_negative(axis);
if (posaxis == depth) {
return combinations_axis0(n, replacement, recordlookup, parameters);
}
else {
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(content.get()->combinations(n,
replacement,
recordlookup,
parameters,
posaxis,
depth));
}
return std::make_shared<RecordArray>(identities_,
util::Parameters(),
contents,
recordlookup_,
length_);
}
}
const ContentPtr
RecordArray::field(int64_t fieldindex) const {
if (fieldindex >= numfields()) {
throw std::invalid_argument(
std::string("fieldindex ") + std::to_string(fieldindex)
+ std::string(" for record with only " + std::to_string(numfields()))
+ std::string(" fields") + FILENAME(__LINE__));
}
return contents_[(size_t)fieldindex];
}
const ContentPtr
RecordArray::field(const std::string& key) const {
return contents_[(size_t)fieldindex(key)];
}
const ContentPtrVec
RecordArray::fields() const {
return ContentPtrVec(contents_);
}
const std::vector<std::pair<std::string, ContentPtr>>
RecordArray::fielditems() const {
std::vector<std::pair<std::string, ContentPtr>> out;
if (istuple()) {
size_t cols = contents_.size();
for (size_t j = 0; j < cols; j++) {
out.push_back(
std::pair<std::string, ContentPtr>(std::to_string(j), contents_[j]));
}
}
else {
size_t cols = contents_.size();
for (size_t j = 0; j < cols; j++) {
out.push_back(
std::pair<std::string, ContentPtr>(recordlookup_.get()->at(j),
contents_[j]));
}
}
return out;
}
const std::shared_ptr<RecordArray>
RecordArray::astuple() const {
return std::make_shared<RecordArray>(identities_,
parameters_,
contents_,
util::RecordLookupPtr(nullptr),
length_,
caches_);
}
const ContentPtr
RecordArray::sort_next(int64_t negaxis,
const Index64& starts,
const Index64& parents,
int64_t outlength,
bool ascending,
bool stable,
bool keepdims) const {
if (length() == 0) {
return shallow_copy();
}
std::vector<ContentPtr> contents;
for (auto content : contents_) {
ContentPtr trimmed = content.get()->getitem_range_nowrap(0, length());
ContentPtr next = trimmed.get()->sort_next(negaxis,
starts,
parents,
outlength,
ascending,
stable,
keepdims);
contents.push_back(next);
}
return std::make_shared<RecordArray>(Identities::none(),
parameters_,
contents,
recordlookup_,
outlength);
}
const ContentPtr
RecordArray::argsort_next(int64_t negaxis,
const Index64& starts,
const Index64& parents,
int64_t outlength,
bool ascending,
bool stable,
bool keepdims) const {
if (length() == 0) {
return shallow_copy();
}
std::vector<ContentPtr> contents;
for (auto content : contents_) {
ContentPtr trimmed = content.get()->getitem_range_nowrap(0, length());
ContentPtr next = trimmed.get()->argsort_next(negaxis,
starts,
parents,
outlength,
ascending,
stable,
keepdims);
contents.push_back(next);
}
return std::make_shared<RecordArray>(
Identities::none(),
util::Parameters(),
contents,
recordlookup_,
outlength);
}
const ContentPtr
RecordArray::getitem_next(const SliceItemPtr& head,
const Slice& tail,
const Index64& advanced) const {
if (head.get() == nullptr) {
return shallow_copy();
}
else if (SliceField* field =
dynamic_cast<SliceField*>(head.get())) {
return Content::getitem_next(*field, tail, advanced);
}
else if (SliceFields* fields =
dynamic_cast<SliceFields*>(head.get())) {
return Content::getitem_next(*fields, tail, advanced);
}
else if (const SliceMissing64* missing =
dynamic_cast<SliceMissing64*>(head.get())) {
return Content::getitem_next(*missing, tail, advanced);
}
else {
SliceItemPtr nexthead = tail.head();
Slice nexttail = tail.tail();
Slice emptytail;
emptytail.become_sealed();
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(content.get()->getitem_next(head,
emptytail,
advanced));
}
util::Parameters parameters;
if (head.get()->preserves_type(advanced)) {
parameters = parameters_;
}
RecordArray out(Identities::none(), parameters, contents, recordlookup_);
return out.getitem_next(nexthead, nexttail, advanced);
}
}
const ContentPtr
RecordArray::getitem_next(const SliceAt& at,
const Slice& tail,
const Index64& advanced) const {
throw std::invalid_argument(
std::string("undefined operation: RecordArray::getitem_next(at)")
+ FILENAME(__LINE__));
}
const ContentPtr
RecordArray::getitem_next(const SliceRange& range,
const Slice& tail,
const Index64& advanced) const {
throw std::invalid_argument(
std::string("undefined operation: RecordArray::getitem_next(range)")
+ FILENAME(__LINE__));
}
const ContentPtr
RecordArray::getitem_next(const SliceArray64& array,
const Slice& tail,
const Index64& advanced) const {
throw std::invalid_argument(
std::string("undefined operation: RecordArray::getitem_next(array)")
+ FILENAME(__LINE__));
}
const ContentPtr
RecordArray::getitem_next(const SliceField& field,
const Slice& tail,
const Index64& advanced) const {
SliceItemPtr nexthead = tail.head();
Slice nexttail = tail.tail();
return getitem_field(field.key()).get()->getitem_next(nexthead,
nexttail,
advanced);
}
const ContentPtr
RecordArray::getitem_next(const SliceFields& fields,
const Slice& tail,
const Index64& advanced) const {
Slice only_fields = tail.only_fields();
Slice not_fields = tail.not_fields();
SliceItemPtr nexthead = not_fields.head();
Slice nexttail = not_fields.tail();
return getitem_fields(fields.keys(), only_fields).get()->getitem_next(nexthead,
nexttail,
advanced);
}
const ContentPtr
RecordArray::getitem_next(const SliceJagged64& jagged,
const Slice& tail,
const Index64& advanced) const {
throw std::invalid_argument(
std::string("undefined operation: RecordArray::getitem_next(jagged)")
+ FILENAME(__LINE__));
}
const ContentPtr
RecordArray::getitem_next_jagged(const Index64& slicestarts,
const Index64& slicestops,
const SliceArray64& slicecontent,
const Slice& tail) const {
return getitem_next_jagged_generic<SliceArray64>(slicestarts,
slicestops,
slicecontent,
tail);
}
const ContentPtr
RecordArray::getitem_next_jagged(const Index64& slicestarts,
const Index64& slicestops,
const SliceMissing64& slicecontent,
const Slice& tail) const {
return getitem_next_jagged_generic<SliceMissing64>(slicestarts,
slicestops,
slicecontent,
tail);
}
const ContentPtr
RecordArray::getitem_next_jagged(const Index64& slicestarts,
const Index64& slicestops,
const SliceJagged64& slicecontent,
const Slice& tail) const {
return getitem_next_jagged_generic<SliceJagged64>(slicestarts,
slicestops,
slicecontent,
tail);
}
const ContentPtr
RecordArray::getitem_next_jagged(const Index64& slicestarts,
const Index64& slicestops,
const SliceVarNewAxis& slicecontent,
const Slice& tail) const {
return getitem_next_jagged_generic<SliceVarNewAxis>(slicestarts,
slicestops,
slicecontent,
tail);
}
const ContentPtr
RecordArray::getitem_next(const SliceVarNewAxis& varnewaxis,
const Slice& tail,
const Index64& advanced) const {
throw std::invalid_argument(
std::string("cannot slice records by a newaxis (length-1 regular dimension)")
+ FILENAME(__LINE__));
}
const SliceJagged64
RecordArray::varaxis_to_jagged(const SliceVarNewAxis& varnewaxis) const {
throw std::invalid_argument(
std::string("cannot slice records by a newaxis (length-1 regular dimension)")
+ FILENAME(__LINE__));
}
const ContentPtr
RecordArray::copy_to(kernel::lib ptr_lib) const {
ContentPtrVec contents;
for (auto content : contents_) {
contents.push_back(content.get()->copy_to(ptr_lib));
}
IdentitiesPtr identities(nullptr);
if (identities_.get() != nullptr) {
identities = identities_.get()->copy_to(ptr_lib);
}
return std::make_shared<RecordArray>(identities,
parameters_,
contents,
recordlookup_,
length_,
caches_);
}
const ContentPtr
RecordArray::numbers_to_type(const std::string& name) const {
ContentPtrVec contents;
for (auto x : contents_) {
contents.push_back(x.get()->numbers_to_type(name));
}
IdentitiesPtr identities = identities_;
if (identities_.get() != nullptr) {
identities = identities_.get()->deep_copy();
}
return std::make_shared<RecordArray>(identities,
parameters_,
contents,
recordlookup_,
length_);
}
template <typename S>
const ContentPtr
RecordArray::getitem_next_jagged_generic(const Index64& slicestarts,
const Index64& slicestops,
const S& slicecontent,
const Slice& tail) const {
if (contents_.empty()) {
return shallow_copy();
}
else {
ContentPtrVec contents;
for (auto content : contents_) {
ContentPtr trimmed = content.get()->getitem_range_nowrap(0, length());
contents.push_back(trimmed.get()->getitem_next_jagged(slicestarts,
slicestops,
slicecontent,
tail));
}
return std::make_shared<RecordArray>(identities_,
parameters_,
contents,
recordlookup_);
}
}
bool
RecordArray::is_unique() const {
if (contents_.empty()) {
return true;
}
else {
int64_t non_unique_count = 0;
for (auto content : contents_) {
if (!content.get()->is_unique()) {
non_unique_count++;
}
else if (non_unique_count == 0) {
return true;
}
}
if (non_unique_count <= 1) {
return true;
}
else {
throw std::runtime_error(
std::string("FIXME: RecordArray::is_unique operation on a RecordArray ")
+ std::string("with more than one non-unique content is not implemented yet")
+ FILENAME(__LINE__));
}
}
return false;
}
const ContentPtr
RecordArray::unique() const {
throw std::runtime_error(
std::string("FIXME: operation not yet implemented: RecordArray::unique")
+ FILENAME(__LINE__));
}
bool
RecordArray::is_subrange_equal(const Index64& start, const Index64& stop) const {
throw std::runtime_error(
std::string("FIXME: operation not yet implemented: RecordArray::is_subrange_equal")
+ FILENAME(__LINE__));
}
}
| 34.331604 | 97 | 0.513899 | HenryDayHall |
29a327f104fa81e5637e6803b8eb8821c8da5f7e | 2,782 | cpp | C++ | src/around_the_world_ygm.cpp | steiltre/ygm-bench | f8ee35154ab2683aad4183cd05d0bd9097abe9df | [
"MIT-0",
"MIT"
] | null | null | null | src/around_the_world_ygm.cpp | steiltre/ygm-bench | f8ee35154ab2683aad4183cd05d0bd9097abe9df | [
"MIT-0",
"MIT"
] | 4 | 2022-03-21T18:20:51.000Z | 2022-03-31T23:52:51.000Z | src/around_the_world_ygm.cpp | steiltre/ygm-bench | f8ee35154ab2683aad4183cd05d0bd9097abe9df | [
"MIT-0",
"MIT"
] | 2 | 2022-03-21T17:37:45.000Z | 2022-03-22T23:08:39.000Z | // Copyright 2019-2021 Lawrence Livermore National Security, LLC and other YGM
// Project Developers. See the top-level COPYRIGHT file for details.
//
// SPDX-License-Identifier: MIT
#include <algorithm>
#include <string>
#include <ygm/comm.hpp>
#include <ygm/utility.hpp>
static int num_trips;
static int curr_trip = 0;
struct around_the_world_functor {
public:
template <typename Comm>
void operator()(Comm *world) {
if (curr_trip < num_trips) {
world->async((world->rank() + 1) % world->size(),
around_the_world_functor());
++curr_trip;
}
}
};
int main(int argc, char **argv) {
ygm::comm world(&argc, &argv);
num_trips = atoi(argv[1]);
int num_trials{atoi(argv[2])};
bool wait_until{false};
const char *wait_until_tmp = std::getenv("YGM_BENCH_ATW_WAIT_UNTIL");
std::string wait_until_str(wait_until_tmp ? wait_until_tmp : "false");
std::transform(
wait_until_str.begin(), wait_until_str.end(), wait_until_str.begin(),
[](unsigned char c) -> unsigned char { return std::tolower(c); });
if (wait_until_str == "true") {
wait_until = true;
}
if (world.rank0()) {
std::cout << world.layout().node_size() << ", "
<< world.layout().local_size() << ", " << world.routing_protocol()
<< ", " << num_trips << ", " << wait_until_str;
}
world.barrier();
for (int trial = 0; trial < num_trials; ++trial) {
curr_trip = 0;
world.barrier();
world.stats_reset();
world.set_track_stats(true);
ygm::timer trip_timer{};
if (world.rank0()) {
world.async(1, around_the_world_functor());
}
if (wait_until) {
world.wait_until([]() { return curr_trip >= num_trips; });
}
world.barrier();
world.set_track_stats(false);
double elapsed = trip_timer.elapsed();
auto trial_stats = world.stats_snapshot();
// world.cout0("Went around the world ", num_trips, " times in ", elapsed,
//" seconds\nAverage trip time: ", elapsed / num_trips);
size_t message_bytes{0};
size_t header_bytes{0};
for (const auto &bytes : trial_stats.get_destination_message_bytes_sum()) {
message_bytes += bytes;
}
for (const auto &bytes : trial_stats.get_destination_header_bytes_sum()) {
header_bytes += bytes;
}
message_bytes = world.all_reduce_sum(message_bytes);
header_bytes = world.all_reduce_sum(header_bytes);
if (world.rank0()) {
auto total_hops = num_trips * world.size();
std::cout << ", " << elapsed << ", " << total_hops / elapsed << ", "
<< header_bytes << ", " << message_bytes << ", "
<< trial_stats.get_all_reduce_count();
}
}
if (world.rank0()) {
std::cout << std::endl;
}
return 0;
}
| 26.245283 | 80 | 0.619698 | steiltre |
29a52f6f691e7a8f94744c268a96a215c2133a20 | 6,344 | cpp | C++ | toonz/sources/stdfx/channelmixerfx.cpp | rozhuk-im/opentoonz | ad5b632512746b97fd526aa79660fbaedf934fad | [
"BSD-3-Clause"
] | 3,710 | 2016-03-26T00:40:48.000Z | 2022-03-31T21:35:12.000Z | toonz/sources/stdfx/channelmixerfx.cpp | rozhuk-im/opentoonz | ad5b632512746b97fd526aa79660fbaedf934fad | [
"BSD-3-Clause"
] | 4,246 | 2016-03-26T01:21:45.000Z | 2022-03-31T23:10:47.000Z | toonz/sources/stdfx/channelmixerfx.cpp | rozhuk-im/opentoonz | ad5b632512746b97fd526aa79660fbaedf934fad | [
"BSD-3-Clause"
] | 633 | 2016-03-26T00:42:25.000Z | 2022-03-17T02:55:13.000Z |
#include "stdfx.h"
#include "tfxparam.h"
//#include "trop.h"
#include <math.h>
#include "tpixelutils.h"
#include "globalcontrollablefx.h"
//==================================================================
class ChannelMixerFx final : public GlobalControllableFx {
FX_PLUGIN_DECLARATION(ChannelMixerFx)
TRasterFxPort m_input;
TDoubleParamP m_r_r;
TDoubleParamP m_g_r;
TDoubleParamP m_b_r;
TDoubleParamP m_m_r;
TDoubleParamP m_r_g;
TDoubleParamP m_g_g;
TDoubleParamP m_b_g;
TDoubleParamP m_m_g;
TDoubleParamP m_r_b;
TDoubleParamP m_g_b;
TDoubleParamP m_b_b;
TDoubleParamP m_m_b;
TDoubleParamP m_r_m;
TDoubleParamP m_g_m;
TDoubleParamP m_b_m;
TDoubleParamP m_m_m;
public:
ChannelMixerFx()
: m_r_r(1.0)
, m_g_r(0.0)
, m_b_r(0.0)
, m_m_r(0.0)
, m_r_g(0.0)
, m_g_g(1.0)
, m_b_g(0.0)
, m_m_g(0.0)
, m_r_b(0.0)
, m_g_b(0.0)
, m_b_b(1.0)
, m_m_b(0.0)
, m_r_m(0.0)
, m_g_m(0.0)
, m_b_m(0.0)
, m_m_m(1.0)
{
addInputPort("Source", m_input);
bindParam(this, "red_to_red", m_r_r);
bindParam(this, "green_to_red", m_g_r);
bindParam(this, "blue_to_red", m_b_r);
bindParam(this, "matte_to_red", m_m_r);
bindParam(this, "red_to_green", m_r_g);
bindParam(this, "green_to_green", m_g_g);
bindParam(this, "blue_to_green", m_b_g);
bindParam(this, "matte_to_green", m_m_g);
bindParam(this, "red_to_blue", m_r_b);
bindParam(this, "green_to_blue", m_g_b);
bindParam(this, "blue_to_blue", m_b_b);
bindParam(this, "matte_to_blue", m_m_b);
bindParam(this, "red_to_matte", m_r_m);
bindParam(this, "green_to_matte", m_g_m);
bindParam(this, "blue_to_matte", m_b_m);
bindParam(this, "matte_to_matte", m_m_m);
m_r_r->setValueRange(0, 1);
m_r_g->setValueRange(0, 1);
m_r_b->setValueRange(0, 1);
m_r_m->setValueRange(0, 1);
m_g_r->setValueRange(0, 1);
m_g_g->setValueRange(0, 1);
m_g_b->setValueRange(0, 1);
m_g_m->setValueRange(0, 1);
m_b_r->setValueRange(0, 1);
m_b_g->setValueRange(0, 1);
m_b_b->setValueRange(0, 1);
m_b_m->setValueRange(0, 1);
m_m_r->setValueRange(0, 1);
m_m_g->setValueRange(0, 1);
m_m_b->setValueRange(0, 1);
m_m_m->setValueRange(0, 1);
}
~ChannelMixerFx(){};
bool doGetBBox(double frame, TRectD &bBox,
const TRenderSettings &info) override {
if (m_input.isConnected())
return m_input->doGetBBox(frame, bBox, info);
else {
bBox = TRectD();
return false;
}
};
void doCompute(TTile &tile, double frame, const TRenderSettings &ri) override;
bool canHandle(const TRenderSettings &info, double frame) override {
return true;
}
};
namespace {
template <typename PIXEL, typename CHANNEL_TYPE>
void depremult(PIXEL *pix) {
if (!pix->m) return;
double depremult = (double)PIXEL::maxChannelValue / pix->m;
pix->r = (CHANNEL_TYPE)(pix->r * depremult);
pix->g = (CHANNEL_TYPE)(pix->g * depremult);
pix->b = (CHANNEL_TYPE)(pix->b * depremult);
}
} // namespace
template <typename PIXEL, typename CHANNEL_TYPE>
void doChannelMixer(TRasterPT<PIXEL> ras, double r_r, double r_g, double r_b,
double r_m, double g_r, double g_g, double g_b, double g_m,
double b_r, double b_g, double b_b, double b_m, double m_r,
double m_g, double m_b, double m_m) {
double aux = (double)PIXEL::maxChannelValue;
int j;
ras->lock();
for (j = 0; j < ras->getLy(); j++) {
PIXEL *pix = ras->pixels(j);
PIXEL *endPix = pix + ras->getLx();
while (pix < endPix) {
depremult<PIXEL, CHANNEL_TYPE>(pix); // if removed, a black line appears
// in the edge of a level (default
// values, not black lines)
double red = pix->r * r_r + pix->g * g_r + pix->b * b_r + pix->m * m_r;
double green = pix->r * r_g + pix->g * g_g + pix->b * b_g + pix->m * m_g;
double blue = pix->r * r_b + pix->g * g_b + pix->b * b_b + pix->m * m_b;
double matte = pix->r * r_m + pix->g * g_m + pix->b * b_m + pix->m * m_m;
red = tcrop(red, 0.0, aux);
green = tcrop(green, 0.0, aux);
blue = tcrop(blue, 0.0, aux);
matte = tcrop(matte, 0.0, aux);
pix->r = (CHANNEL_TYPE)red;
pix->g = (CHANNEL_TYPE)green;
pix->b = (CHANNEL_TYPE)blue;
pix->m = (CHANNEL_TYPE)matte;
*pix = premultiply(*pix); // if removed, a white edged line appears in
// the edge of a level (if m>r, g, b)
pix++;
}
}
ras->unlock();
}
//------------------------------------------------------------------------------
void ChannelMixerFx::doCompute(TTile &tile, double frame,
const TRenderSettings &ri) {
if (!m_input.isConnected()) return;
m_input->compute(tile, frame, ri);
double r_r = m_r_r->getValue(frame);
double r_g = m_r_g->getValue(frame);
double r_b = m_r_b->getValue(frame);
double r_m = m_r_m->getValue(frame);
double g_r = m_g_r->getValue(frame);
double g_g = m_g_g->getValue(frame);
double g_b = m_g_b->getValue(frame);
double g_m = m_g_m->getValue(frame);
double b_r = m_b_r->getValue(frame);
double b_g = m_b_g->getValue(frame);
double b_b = m_b_b->getValue(frame);
double b_m = m_b_m->getValue(frame);
double m_r = m_m_r->getValue(frame);
double m_g = m_m_g->getValue(frame);
double m_b = m_m_b->getValue(frame);
double m_m = m_m_m->getValue(frame);
TRaster32P raster32 = tile.getRaster();
if (raster32)
doChannelMixer<TPixel32, UCHAR>(raster32, r_r, r_g, r_b, r_m, g_r, g_g, g_b,
g_m, b_r, b_g, b_b, b_m, m_r, m_g, m_b,
m_m);
else {
TRaster64P raster64 = tile.getRaster();
if (raster64)
doChannelMixer<TPixel64, USHORT>(raster64, r_r, r_g, r_b, r_m, g_r, g_g,
g_b, g_m, b_r, b_g, b_b, b_m, m_r, m_g,
m_b, m_m);
else
throw TException("Brightness&Contrast: unsupported Pixel Type");
}
}
FX_PLUGIN_IDENTIFIER(ChannelMixerFx, "channelMixerFx")
| 33.21466 | 80 | 0.584016 | rozhuk-im |
29a603fb54da5e32d67f16238b519000b88f27ab | 7,084 | cpp | C++ | src/caffe/syncedmem.cpp | Amanda-Barbara/nvcaffe | 5155a708b235a818ce300aa3f9fc235ece9a35fb | [
"BSD-2-Clause"
] | 758 | 2015-03-08T20:54:38.000Z | 2022-01-11T03:14:51.000Z | src/caffe/syncedmem.cpp | Matsuko9/caffe | 17e347e42e664b87d80f63bfbbb89bec5e559242 | [
"BSD-2-Clause"
] | 493 | 2015-04-28T00:08:53.000Z | 2021-08-04T07:26:54.000Z | src/caffe/syncedmem.cpp | Matsuko9/caffe | 17e347e42e664b87d80f63bfbbb89bec5e559242 | [
"BSD-2-Clause"
] | 389 | 2015-03-05T12:11:44.000Z | 2022-03-13T21:49:42.000Z | #include "caffe/common.hpp"
#include "caffe/syncedmem.hpp"
#include "caffe/type.hpp"
#include "caffe/util/gpu_memory.hpp"
#include "caffe/util/math_functions.hpp"
#define MAX_ELEM_TO_SHOW 20UL
namespace caffe {
// If CUDA is available and in GPU mode, host memory will be allocated pinned,
// using cudaMallocHost. It avoids dynamic pinning for transfers (DMA).
// The improvement in performance seems negligible in the single GPU case,
// but might be more significant for parallel training. Most importantly,
// it improved stability for large models on many GPUs.
void SyncedMemory::MallocHost(void** ptr, size_t size, bool* use_cuda) {
if (Caffe::mode() == Caffe::GPU) {
CUDA_CHECK(cudaMallocHost(ptr, size));
*use_cuda = true;
} else {
*ptr = malloc(size);
*use_cuda = false;
}
}
void SyncedMemory::FreeHost(void* ptr, bool use_cuda) {
if (use_cuda) {
CUDA_CHECK(cudaFreeHost(ptr));
} else {
free(ptr);
}
}
SyncedMemory::~SyncedMemory() {
if (cpu_ptr_ && own_cpu_data_) {
FreeHost(cpu_ptr_, cpu_malloc_use_cuda_);
}
if (gpu_ptr_ && own_gpu_data_) {
//#ifdef DEBUG
// cudaPointerAttributes attr;
// cudaError_t status = cudaPointerGetAttributes(&attr, gpu_ptr_);
// if (status == cudaSuccess) {
// CHECK_EQ(attr.memoryType, cudaMemoryTypeDevice);
// CHECK_EQ(attr.device, device_);
// }
//#endif
GPUMemory::deallocate(gpu_ptr_, device_);
}
}
void SyncedMemory::to_cpu(bool copy_from_gpu, int group) {
switch (head_) {
case UNINITIALIZED:
MallocHost(&cpu_ptr_, size_, &cpu_malloc_use_cuda_);
caffe_memset(size_, 0, cpu_ptr_);
head_ = HEAD_AT_CPU;
own_cpu_data_ = true;
break;
case HEAD_AT_GPU:
if (cpu_ptr_ == NULL) {
MallocHost(&cpu_ptr_, size_, &cpu_malloc_use_cuda_);
own_cpu_data_ = true;
}
if (copy_from_gpu) {
caffe_gpu_memcpy(size_, gpu_ptr_, cpu_ptr_, group);
head_ = SYNCED;
} else {
head_ = HEAD_AT_CPU;
}
break;
case HEAD_AT_CPU:
case SYNCED:
break;
}
}
void SyncedMemory::to_gpu(bool copy_from_cpu, int group) {
switch (head_) {
case UNINITIALIZED:
CUDA_CHECK(cudaGetDevice(&device_));
pstream_ = Caffe::thread_pstream(group);
GPUMemory::allocate(&gpu_ptr_, size_, device_, pstream_);
caffe_gpu_memset(size_, 0, gpu_ptr_, group);
head_ = HEAD_AT_GPU;
own_gpu_data_ = true;
break;
case HEAD_AT_CPU:
if (gpu_ptr_ == NULL) {
CUDA_CHECK(cudaGetDevice(&device_));
pstream_ = Caffe::thread_pstream(group);
GPUMemory::allocate(&gpu_ptr_, size_, device_, pstream_);
own_gpu_data_ = true;
}
if (copy_from_cpu) {
caffe_gpu_memcpy(size_, cpu_ptr_, gpu_ptr_, group);
head_ = SYNCED;
} else {
head_ = HEAD_AT_GPU;
}
break;
case HEAD_AT_GPU:
case SYNCED:
break;
}
}
const void* SyncedMemory::cpu_data() {
to_cpu();
return (const void*) cpu_ptr_;
}
void SyncedMemory::set_cpu_data(void* data) {
CHECK(data);
if (own_cpu_data_) {
FreeHost(cpu_ptr_, cpu_malloc_use_cuda_);
}
cpu_ptr_ = data;
head_ = HEAD_AT_CPU;
own_cpu_data_ = false;
}
const void* SyncedMemory::gpu_data(int group) {
to_gpu(true, group);
return (const void*) gpu_ptr_;
}
void SyncedMemory::set_gpu_data(void* data) {
CHECK(data);
if (gpu_ptr_ && own_gpu_data_) {
GPUMemory::deallocate(gpu_ptr_, device_);
}
gpu_ptr_ = data;
head_ = HEAD_AT_GPU;
own_gpu_data_ = false;
}
void* SyncedMemory::mutable_cpu_data(bool copy_from_gpu, int group) {
to_cpu(copy_from_gpu, group);
head_ = HEAD_AT_CPU;
return cpu_ptr_;
}
void* SyncedMemory::mutable_gpu_data(bool copy_from_cpu, int group) {
to_gpu(copy_from_cpu, group);
head_ = HEAD_AT_GPU;
return gpu_ptr_;
}
std::string SyncedMemory::to_string(int indent, Type type) { // debug helper
const std::string idt(indent, ' ');
std::ostringstream os;
os << idt << "SyncedMem " << this << ", size: " << size_ << ", type: " << Type_Name(type)
<< std::endl;
os << idt << "head_: ";
switch (head_) {
case UNINITIALIZED:
os << "UNINITIALIZED";
break;
case HEAD_AT_CPU:
os << "HEAD_AT_CPU";
break;
case HEAD_AT_GPU:
os << "HEAD_AT_GPU";
break;
case SYNCED:
os << "SYNCED";
break;
default:
os << "???";
break;
}
os << std::endl;
os << idt << "cpu_ptr_, gpu_ptr_: " << cpu_ptr_ << " " << gpu_ptr_ << std::endl;
os << idt << "own_cpu_data_, own_gpu_data_: " << own_cpu_data_ << " " << own_gpu_data_
<< std::endl;
os << idt << "cpu_malloc_use_cuda_, gpu_device_: " << cpu_malloc_use_cuda_ << " " << device_
<< std::endl;
os << idt << "valid_: " << valid_ << std::endl;
const void* data = cpu_data();
if (is_type<float>(type)) {
const float* fdata = static_cast<const float*>(data);
size_t n = std::min(size_ / sizeof(float), MAX_ELEM_TO_SHOW);
os << idt << "First " << n << " elements:";
for (size_t i = 0; i < n; ++i) {
os << " " << fdata[i];
}
os << std::endl;
os << idt << "First corrupted elements (if any):";
int j = 0;
for (size_t i = 0; i < size_ / sizeof(float) && j < MAX_ELEM_TO_SHOW; ++i) {
if (std::isinf(fdata[i]) || std::isnan(fdata[i])) {
os << idt << i << "->" << fdata[i] << " ";
++j;
}
}
os << std::endl;
} else if (is_type<float16>(type)) {
const float16* fdata = static_cast<const float16*>(data);
size_t n = std::min(size_ / sizeof(float16), MAX_ELEM_TO_SHOW);
os << idt << "First " << n << " elements:";
for (size_t i = 0; i < n; ++i) {
os << " " << float(fdata[i]);
}
os << std::endl;
os << idt << "First corrupted elements (if any):";
int j = 0;
for (size_t i = 0; i < size_ / sizeof(float16) && j < MAX_ELEM_TO_SHOW; ++i) {
if (std::isinf(fdata[i]) || std::isnan(fdata[i])) {
os << i << "->" << float(fdata[i]) << " ";
++j;
}
}
os << std::endl;
} else if (is_type<double>(type)) {
const double* fdata = static_cast<const double*>(data);
size_t n = std::min(size_ / sizeof(double), MAX_ELEM_TO_SHOW);
os << idt << "First " << n << " elements:";
for (size_t i = 0; i < n; ++i) {
os << " " << fdata[i];
}
} else if (is_type<unsigned int>(type)) {
const unsigned int* fdata = static_cast<const unsigned int*>(data);
size_t n = std::min(size_ / sizeof(unsigned int), MAX_ELEM_TO_SHOW);
os << idt << "First " << n << " elements:";
for (size_t i = 0; i < n; ++i) {
os << " " << fdata[i];
}
} else if (is_type<int>(type)) {
const int* fdata = static_cast<const int*>(data);
size_t n = std::min(size_ / sizeof(int), MAX_ELEM_TO_SHOW);
os << idt << "First " << n << " elements:";
for (size_t i = 0; i < n; ++i) {
os << " " << fdata[i];
}
} else {
LOG(FATAL) << "Unsupported data type: " << Type_Name(type);
}
os << std::endl;
return os.str();
}
} // namespace caffe
| 29.032787 | 94 | 0.600085 | Amanda-Barbara |
29a70f50fbea4c6ffa18e9527367ee4e49a69d32 | 126 | cpp | C++ | src/sylvan/queens.cpp | SSoelvsten/bdd-benchmark | f1176feb1584ed8a40bbd6ca975c5d8770d5786c | [
"MIT"
] | 3 | 2021-02-05T10:03:53.000Z | 2022-03-24T08:31:40.000Z | src/sylvan/queens.cpp | SSoelvsten/bdd-benchmark | f1176feb1584ed8a40bbd6ca975c5d8770d5786c | [
"MIT"
] | 7 | 2020-11-20T13:48:01.000Z | 2022-03-05T16:52:12.000Z | src/sylvan/queens.cpp | SSoelvsten/bdd-benchmark | f1176feb1584ed8a40bbd6ca975c5d8770d5786c | [
"MIT"
] | 1 | 2021-04-25T07:06:17.000Z | 2021-04-25T07:06:17.000Z | #include "../queens.cpp"
#include "package_mgr.h"
int main(int argc, char** argv)
{
run_queens<sylvan_mgr>(argc, argv);
}
| 14 | 37 | 0.674603 | SSoelvsten |
29a8e7b253d82f06641e89c5b659108250fed228 | 3,316 | cc | C++ | neighborhood-sgd.cc | lemrobotry/thesis | 14ad489e8f04cb957707b89c454ee7d81ec672ad | [
"MIT"
] | null | null | null | neighborhood-sgd.cc | lemrobotry/thesis | 14ad489e8f04cb957707b89c454ee7d81ec672ad | [
"MIT"
] | null | null | null | neighborhood-sgd.cc | lemrobotry/thesis | 14ad489e8f04cb957707b89c454ee7d81ec672ad | [
"MIT"
] | null | null | null | #include "Application.hh"
#include "GradientChart.hh"
#include "ParseController.hh"
#include "PV.hh"
#include "SGD.hh"
APPLICATION
using namespace Permute;
class NeighborhoodSGD : public Application {
private:
static Core::ParameterFloat paramLearningRate;
double LEARNING_RATE;
static Core::ParameterInt paramPartK;
static Core::ParameterInt paramPartMod;
int K, MOD;
public:
NeighborhoodSGD () :
Application ("neighborhood-sgd")
{}
virtual void getParameters () {
Application::getParameters ();
LEARNING_RATE = paramLearningRate (config);
K = paramPartK (config);
MOD = paramPartMod (config);
}
virtual void printParameterDescription (std::ostream & out) const {
paramLearningRate.printShortHelp (out);
paramPartK.printShortHelp (out);
paramPartMod.printShortHelp (out);
}
int main (const std::vector <std::string> & args) {
this -> getParameters ();
UpdateSGD update_sgd (LEARNING_RATE);
PV pv;
if (! this -> readPV (pv)) {
return EXIT_FAILURE;
}
std::vector <WRef> weights (pv.size ());
std::transform (pv.begin (), pv.end (),
weights.begin (),
std::select2nd <PV::value_type> ());
std::vector <double> values (weights.size ());
std::vector <double> weightSum (weights.size (), 0.0);
double count = 0.0;
Permutation source, target, pos, labels;
std::vector <int> parents;
ParseControllerRef controller (CubicParseController::create ());
std::istream & input = this -> input ();
for (int sentence = 0;
sentence < SENTENCES && readPermutationWithAlphabet (source, input);
++ sentence) {
std::cerr << sentence << " " << source.size () << std::endl;
readPermutationWithAlphabet (pos, input);
if (DEPENDENCY) {
readParents (parents, input);
readPermutationWithAlphabet (labels, input);
}
target = source;
readAlignment (target, input);
if (sentence % MOD == K) {
// Copies the current parameter values so gradients can be accumulated
// in place.
std::copy (weights.begin (), weights.end (),
values.begin ());
// Computes the gradient of the parameters with respect to the log
// likelihood of the current target permutation given its neighborhood.
SumBeforeCostRef bc (new SumBeforeCost (source.size (), "NeighborhoodSGD"));
this -> sumBeforeCost (bc, pv, source, pos, parents, labels);
GradientScorer scorer (bc, target);
GradientChart chart (target);
chart.parse (controller, scorer, pv);
// Updates the parameters: values holds the current parameters, and
// weights holds their gradients. Transforms the pair using UpdateSGD
// and assigns to weights.
std::transform(values.begin (), values.end (),
weights.begin (),
weights.begin (),
update_sgd);
update (weightSum, weights);
++ count;
}
}
Permute::set (weights, weightSum, 1.0 / count);
this -> writePV (pv);
return EXIT_SUCCESS;
}
} app;
Core::ParameterFloat NeighborhoodSGD::paramLearningRate ("rate", "the learning rate for SGD", 1.0, 0.0);
Core::ParameterInt NeighborhoodSGD::paramPartK ("k", "the remainder (mod --mod) of the sentences to use for training", 0, 0);
Core::ParameterInt NeighborhoodSGD::paramPartMod ("mod", "the number of parts in use for training", 1, 1);
| 30.145455 | 125 | 0.674005 | lemrobotry |
29ab1c9fa868820a033c2e0e664eca05cd71dd31 | 19,832 | cpp | C++ | Source/Director.cpp | bptigg/CovidSim | 6709bafdce0dfb35f3515f47a5a5199b2c3363f3 | [
"MIT"
] | 2 | 2020-07-15T12:36:55.000Z | 2020-08-02T09:53:54.000Z | Source/Director.cpp | bptigg/CovidSim | 6709bafdce0dfb35f3515f47a5a5199b2c3363f3 | [
"MIT"
] | 1 | 2020-07-04T09:23:50.000Z | 2020-07-04T09:31:27.000Z | Source/Director.cpp | bptigg/CovidSim | 6709bafdce0dfb35f3515f47a5a5199b2c3363f3 | [
"MIT"
] | null | null | null | #include "Director.h"
bool Director::task_permission(Actor::State state)
{
if (state == Actor::idle && m_current_tasks.size() <= max_actors_not_idle && sleep_active == false)
{
return true;
}
else
{
return false;
}
}
void Director::change_actor_location(Actor* actor, Task task, bool task_end)
{
auto [public_Buildings, education_Buildings, public_transport_building, house, generic_work] = task.location_type;
if (task_end != true)
{
if (std::get<0>(task.location_type) != NULL)
{
std::get<0>(task.location_type)->add_people_buiding(actor);
actor->set_location_state(Actor::public_building);
return;
}
if (std::get<1>(task.location_type) != NULL)
{
std::get<1>(task.location_type)->add_people_buiding(actor);
actor->set_location_state(Actor::work);
return;
}
if (std::get<2>(task.location_type) != NULL)
{
std::get<2>(task.location_type)->add_people_buiding(actor);
actor->set_location_state(Actor::work);
return;
}
if (std::get<3>(task.location_type) != NULL)
{
std::get<3>(task.location_type)->add_people_buiding(actor);
actor->set_location_state(Actor::home);
return;
}
if (std::get<4>(task.location_type) != NULL)
{
std::get<4>(task.location_type)->add_people_buiding(actor);
actor->set_location_state(Actor::work);
return;
}
}
else
{
if (std::get<0>(task.location_type) != NULL)
{
std::get<0>(task.location_type)->remove_people_building(actor);
actor->set_location_state(Actor::outside);
std::get<0>(task.location_type)->assigned_tasks = std::get<0>(task.location_type)->assigned_tasks - 1;
return;
}
if (std::get<1>(task.location_type) != NULL)
{
std::get<1>(task.location_type)->remove_people_building(actor);
actor->set_location_state(Actor::outside);
std::get<1>(task.location_type)->assigned_tasks = std::get<1>(task.location_type)->assigned_tasks - 1;
return;
}
if (std::get<2>(task.location_type) != NULL)
{
std::get<2>(task.location_type)->remove_people_building(actor);
actor->set_location_state(Actor::outside);
return;
}
if (std::get<3>(task.location_type) != NULL)
{
std::get<3>(task.location_type)->remove_people_building(actor);
actor->set_location_state(Actor::outside);
return;
}
if (std::get<4>(task.location_type) != NULL)
{
std::get<4>(task.location_type)->remove_people_building(actor);
actor->set_location_state(Actor::outside);
return;
}
}
}
void Director::world_task(mandatory_task task_type, int length)
{
clear_task_vector();
mandatorytask = true;
if (task_type != mandatory_task::sleep)
{
for (auto actor : m_population)
{
if (task_type == mandatory_task::go_home)
{
Task* task = new Task;
task->location_type = { NULL, NULL, NULL, actor->Home, NULL };
task->location = actor->House_Location();
task->task_length = length;
int delay = Random::random_number(0, 10, {});
actor->set_state(Actor::waiting);
m_current_tasks.push_back({ task, actor, delay });
}
else if (task_type == mandatory_task::go_to_work)
{
Task* task = new Task;
task->task_length = length;
//int x = std::get<0>(actor->Work_Location());
//int y = std::get<1>(actor->Work_Location());
//int tile_num = std::get<2>(actor->Work_Location());
//Generic_work* work = new Generic_work;
//Education_Buildings* school = new Education_Buildings;
//Public_Buildings* Work = new Public_Buildings;
//Public_transport_building* work_public_transport = new Public_transport_building;
if (actor->trasnport_work != NULL)
{
task->location_type = { NULL, NULL, actor->trasnport_work, NULL, NULL };
}
else if (actor->public_work != NULL)
{
task->location_type = { actor->public_work, NULL, NULL, NULL, NULL };
}
else if (actor->edu_work != NULL)
{
task->location_type = { NULL, actor->edu_work, NULL, NULL, NULL };
}
else if (actor->gen_work != NULL)
{
task->location_type = { NULL, NULL, NULL, NULL, actor->gen_work };
}
/*
bool found = false;
int a = 0;
for (int i = 0; i < m_tiles[tile_num]->Generic_work.size(); i++)
{
if (std::find(m_tiles[tile_num]->Generic_work[i]->Get_employees().begin(), m_tiles[tile_num]->Generic_work[i]->Get_employees().end(), actor) != m_tiles[tile_num]->Generic_work[i]->Get_employees().end())
{
found = true;
}
a++;
}
if (found == true)
{
task->location_type = { NULL, NULL, NULL, NULL, m_tiles[tile_num]->Generic_work[a] };
if (m_tiles[tile_num]->Generic_work[a]->closed == true)
{
delete task;
continue;
}
}
else
{
a = 0;
for (int i = 0; i < m_tiles[tile_num]->edu_buildings.size(); i++)
{
if (m_tiles[tile_num]->edu_buildings[i]->Get_Location() == actor->Work_Location())
{
found = true;
}
a++;
}
if (found == true)
{
task->location_type = { NULL, m_tiles[tile_num]->edu_buildings[a], NULL, NULL, NULL };
if (m_tiles[tile_num]->edu_buildings[a]->closed == true)
{
delete task;
continue;
}
}
else
{
a = 0;
for (int i = 0; i < m_tiles[tile_num]->Pub_buildings.size(); i++)
{
if (m_tiles[tile_num]->Pub_buildings[i]->Get_Location() == actor->Work_Location())
{
found = true;
}
a++;
}
if (found == true)
{
task->location_type = { m_tiles[tile_num]->Pub_buildings[a], NULL, NULL, NULL, NULL };
if (m_tiles[tile_num]->Pub_buildings[a]->closed == true)
{
delete task;
continue;
}
}
else
{
a = 0;
for (int i = 0; i < m_tiles[tile_num]->public_transport.size(); i++)
{
if (m_tiles[tile_num]->public_transport[i]->Get_Location() == actor->Work_Location())
{
found = true;
}
a++;
}
if (found == true)
{
task->location_type = { NULL, NULL, m_tiles[tile_num]->public_transport[a], NULL, NULL };
}
}
}
}
*/
task->location = actor->Work_Location();
int delay = Random::random_number(0, 10, {});
std::tuple<int, int, int> null_tuple = { 0,0,0 };
if (task->location != null_tuple)
{
actor->set_state(Actor::waiting);
m_current_tasks.push_back({ task, actor, delay });
}
else
{
delete task;
}
}
else if (task_type == mandatory_task::idle)
{
mandatorytask = false;
int x = 0;
if (actor->state_check() != Actor::idle)
{
actor->set_state(Actor::idle);
actor->idle_counts = 0;
if (actor->state_check() == Actor::in_transit && m_transit.size() != 0)
{
find_in_vector(m_transit, x, actor);
m_transit.erase(m_transit.begin() + x);
m_idle.push_back(actor);
//actor->set_state(Actor::idle);
}
if (actor->state_check() == Actor::doing_task && m_doing_task.size() != 0)
{
find_in_vector(m_doing_task, x, actor);
m_doing_task.erase(m_doing_task.begin() + x);
m_idle.push_back(actor);
//actor->set_state(Actor::idle);
}
}
}
}
}
else if (task_type == mandatory_task::sleep)
{
mandatorytask = false;
if (sleep_active == false)
{
sleep_active = true;
}
else
{
sleep_active = false;
}
}
}
void Director::run_tasks()
{
Log log_tasks(Log::LogLevelWarning);
for (int i = 0; i < m_current_tasks.size(); i++)
{
if (std::get<2>(m_current_tasks[i]) == 0)
{
Actor* agent = std::get<1>(m_current_tasks[i]);
if (agent->Get_Location() != std::get<0>(m_current_tasks[i])->location)
{
agent->go_to_place(std::get<0>(m_current_tasks[i])->location, m_transport_net, m_tile_matrix);
if (agent->A_star_found == false)
{
delete std::get<0>(m_current_tasks[i]);
agent->set_state(Actor::idle);
m_current_tasks.erase(m_current_tasks.begin() + i);
log_tasks.LogFucntion(Log::LogLevelWarning, 4);
failed++;
continue;
}
continue;
}
if (agent->Get_Location() == std::get<0>(m_current_tasks[i])->location && agent->task_dest == false)
{
change_actor_location(agent, *std::get<0>(m_current_tasks[i]), false);
agent->set_state(Actor::doing_task);
agent->task_dest = true;
int x = 0;
//find_in_vector(m_transit, x, agent);
//m_doing_task.push_back(agent);
continue;
}
if (std::get<0>(m_current_tasks[i])->run_time == std::get<0>(m_current_tasks[i])->task_length)
{
change_actor_location(agent, *std::get<0>(m_current_tasks[i]), true);
agent->set_state(Actor::idle);
agent->task_dest = false;
m_current_tasks.erase(m_current_tasks.begin() + i);
//m_idle.push_back(agent);
continue;
}
else
{
std::get<0>(m_current_tasks[i])->run_time = std::get<0>(m_current_tasks[i])->run_time + 1;
}
}
else
{
/*auto [task, agent, delay] = m_current_tasks[i];
m_current_tasks.erase(m_current_tasks.begin() + i);
m_current_tasks.push_back({ task, agent, delay - 1 });*/
std::get<2>(m_current_tasks[i]) += -1;
}
}
//std::cin.get();
}
void Director::go_to_hospital(std::vector<Actor*>& patients)
{
for (int i = 0; i < patients.size(); i++)
{
uint32_t tile = 0;
uint32_t tile_1 = tile;
tile = std::get<2>(patients[i]->House_coord);
bool hospital = false;
bool no_hospital = false;
while(hospital == false && no_hospital == false)
{
for (int e = 0; e < m_tiles[tile]->Pub_buildings.size(); e++)
{
if (m_tiles[tile]->Pub_buildings[e]->Get_Type() == Public_Buildings::Hospital)
{
if (m_tiles[tile]->Pub_buildings[e]->Get_people_currently_in_buildling().size() != m_tiles[tile]->Pub_buildings[e]->Get_capacity())
{
m_tiles[tile]->Pub_buildings[e]->patients.push_back(patients[i]);
m_tiles[tile]->Pub_buildings[e]->add_people_buiding(patients[i]);
patients[i]->m_x = std::get<0>(m_tiles[tile]->Pub_buildings[e]->Get_Location());
patients[i]->m_y = std::get<1>(m_tiles[tile]->Pub_buildings[e]->Get_Location());
patients[i]->m_tilenum = std::get<2>(m_tiles[tile]->Pub_buildings[e]->Get_Location());
hospital = true;
break;
}
}
}
tile++;
if (tile == m_tiles.size())
{
tile = 0;
}
if (tile == tile_1)
{
no_hospital = true;
}
}
if (no_hospital == true)
{
patients[i]->hospital = false;
break;
}
}
}
unsigned int Director::generate_random_task(Actor::Age_Catagory age_cat, Tasks::Time_of_day time)
{
std::vector<unsigned int> task;
if (age_cat == Actor::zero_to_four)
{
std::vector<double> weights = task_weight_vector(m_tasks.task0_4, time);
task = Random::Discrete_distribution(weights, 1);
return task[0];
}
else if (age_cat == Actor::five_to_seventeen)
{
std::vector<double> weights = task_weight_vector(m_tasks.task5_17, time);
task = Random::Discrete_distribution(weights, 1);
return task[0];
}
else if (age_cat == Actor::eighteen_to_fortynine || age_cat == Actor::fifty_to_sixtyfour)
{
std::vector<double> weights = task_weight_vector(m_tasks.task18_64, time);
task = Random::Discrete_distribution(weights, 1);
return task[0];
}
else
{
std::vector<double> weights = task_weight_vector(m_tasks.task65, time);
task = Random::Discrete_distribution(weights, 1);
return task[0];
}
}
std::tuple<std::tuple<int, int, int>, Public_Buildings*> Director::public_task_setup(int& actor_tile, Tasks::Destination_Types location_type)
{
int num_of_building_type = 0;
std::vector<Public_Buildings*> public_buildings;
switch (location_type)
{
case 0:
for (int i = 0; i < m_tiles[actor_tile]->Pub_buildings.size(); i++)
{
if (m_tiles[actor_tile]->Pub_buildings[i]->Get_Type() == Public_Buildings::Hospital)
{
public_buildings.push_back(m_tiles[actor_tile]->Pub_buildings[i]);
}
}
break;
case 1:
for (int i = 0; i < m_tiles[actor_tile]->Pub_buildings.size(); i++)
{
if (m_tiles[actor_tile]->Pub_buildings[i]->Get_Type() == Public_Buildings::Place_of_worship)
{
public_buildings.push_back(m_tiles[actor_tile]->Pub_buildings[i]);
}
}
break;
case 2:
for (int i = 0; i < m_tiles[actor_tile]->Pub_buildings.size(); i++)
{
if (m_tiles[actor_tile]->Pub_buildings[i]->Get_Type() == Public_Buildings::restuarant)
{
public_buildings.push_back(m_tiles[actor_tile]->Pub_buildings[i]);
}
}
break;
case 3:
for (int i = 0; i < m_tiles[actor_tile]->Pub_buildings.size(); i++)
{
if (m_tiles[actor_tile]->Pub_buildings[i]->Get_Type() == Public_Buildings::cinema)
{
public_buildings.push_back(m_tiles[actor_tile]->Pub_buildings[i]);
}
}
break;
case 4:
for (int i = 0; i < m_tiles[actor_tile]->Pub_buildings.size(); i++)
{
if (m_tiles[actor_tile]->Pub_buildings[i]->Get_Type() == Public_Buildings::shopping_center)
{
public_buildings.push_back(m_tiles[actor_tile]->Pub_buildings[i]);
}
}
break;
case 5:
for (int i = 0; i < m_tiles[actor_tile]->Pub_buildings.size(); i++)
{
if (m_tiles[actor_tile]->Pub_buildings[i]->Get_Type() == Public_Buildings::parks)
{
public_buildings.push_back(m_tiles[actor_tile]->Pub_buildings[i]);
}
}
break;
}
int random_building = Random::random_number(0, public_buildings.size() + 1, {});
if (random_building < public_buildings.size())
{
return { m_tiles[actor_tile]->Pub_buildings[random_building]->Get_Location(), m_tiles[actor_tile]->Pub_buildings[random_building] };
}
else
{
std::vector<std::vector<Public_Buildings*>> public_buildings_tile;
for (int32_t a = 0; a < m_tiles.size(); a++)
{
if (a == actor_tile)
{
continue;
}
public_buildings.clear();
switch (location_type)
{
case 0:
for (int i = 0; i < m_tiles[a]->Pub_buildings.size(); i++)
{
if (m_tiles[a]->Pub_buildings[i]->Get_Type() == Public_Buildings::Hospital)
{
public_buildings.push_back(m_tiles[a]->Pub_buildings[i]);
}
}
//public_buildings_tile.push_back(public_buildings);
break;
case 1:
for (int i = 0; i < m_tiles[a]->Pub_buildings.size(); i++)
{
if (m_tiles[a]->Pub_buildings[i]->Get_Type() == Public_Buildings::Place_of_worship)
{
public_buildings.push_back(m_tiles[a]->Pub_buildings[i]);
}
}
//public_buildings_tile.push_back(public_buildings);
break;
case 2:
for (int i = 0; i < m_tiles[a]->Pub_buildings.size(); i++)
{
if (m_tiles[a]->Pub_buildings[i]->Get_Type() == Public_Buildings::restuarant)
{
public_buildings.push_back(m_tiles[a]->Pub_buildings[i]);
}
}
//public_buildings_tile.push_back(public_buildings);
break;
case 3:
for (int i = 0; i < m_tiles[a]->Pub_buildings.size(); i++)
{
if (m_tiles[a]->Pub_buildings[i]->Get_Type() == Public_Buildings::cinema)
{
public_buildings.push_back(m_tiles[a]->Pub_buildings[i]);
}
}
//public_buildings_tile.push_back(public_buildings);
break;
case 4:
for (int i = 0; i < m_tiles[a]->Pub_buildings.size(); i++)
{
if (m_tiles[a]->Pub_buildings[i]->Get_Type() == Public_Buildings::shopping_center)
{
public_buildings.push_back(m_tiles[a]->Pub_buildings[i]);
}
}
//public_buildings_tile.push_back(public_buildings);
break;
case 5:
for (int i = 0; i < m_tiles[a]->Pub_buildings.size(); i++)
{
if (m_tiles[a]->Pub_buildings[i]->Get_Type() == Public_Buildings::parks)
{
public_buildings.push_back(m_tiles[a]->Pub_buildings[i]);
}
}
break;
}
if (public_buildings.size() != 0)
{
public_buildings_tile.push_back(public_buildings);
}
}
bool empty_vec = true;
int random_vec;
std::vector<unsigned int> used_numbers = {};
if (public_buildings_tile.size() == 0)
{
return { {0,0,0}, NULL };
}
while (empty_vec == true)
{
random_vec = Random::random_number(0, public_buildings_tile.size() - 1, used_numbers);
if (public_buildings_tile[random_vec].size() != 0)
{
empty_vec = false;
}
used_numbers.push_back(random_vec);
}
random_building = Random::random_number(0, public_buildings_tile[random_vec].size() - 1, {});
return { public_buildings_tile[random_vec][random_building]->Get_Location(), public_buildings_tile[random_vec][random_building] };
}
return { {0,0,0}, NULL };
}
bool Director::find_in_vector(const std::vector<Actor*>& vector, int& position, const Actor* value)
{
bool found = false;
while (found == false)
{
if (position == vector.size())
{
return false;
}
else if (value == vector[position])
{
return true;
}
else
{
position++;
}
}
return false;
}
std::vector<double> Director::task_weight_vector(const std::vector<std::tuple<Tasks::Destination_Types, std::vector<Tasks::Time_of_day>>>& task_vector, const Tasks::Time_of_day& time)
{
std::vector<double> weight_vector;
std::vector<int> extra;
double extra_prob = 0;
for (int i = 0; i < task_vector.size(); i++)
{
double a = 1 / task_vector.size();
if (std::find(std::get<1>(task_vector[i]).begin(), std::get<1>(task_vector[i]).end(), time) != std::get<1>(task_vector[i]).end() || std::get<1>(task_vector[i])[0] == Tasks::all)
{
extra.push_back(i);
extra_prob = extra_prob + get_time_modifier();
}
}
double a = (1 - extra_prob) / 6;
for (int i = 0; i < 6; i++)
{
if (std::find(extra.begin(), extra.end(), i) == extra.end())
{
weight_vector.push_back(a);
}
else
{
weight_vector.push_back(a + get_time_modifier());
}
}
return weight_vector;
}
void Director::clear_task_vector()
{
for (int i = 0; i < m_current_tasks.size(); i++)
{
delete std::get<0>(m_current_tasks[i]);
}
m_current_tasks.clear();
}
Director::Director(std::vector<Actor*>& population, std::vector<Tile*>& tiles, Matrix<int>& tile_matrix, Transport_Net& net)
:m_population(population), m_tiles(tiles), m_tile_matrix(tile_matrix), m_transport_net(&net), m_idle(population)
{
for (int i = 0; i < population.size(); i++)
{
m_transit.push_back(NULL);
}
for (int i = 0; i < population.size(); i++)
{
m_doing_task.push_back(NULL);
}
for (int i = 0; i < population.size(); i++)
{
m_outside.push_back(NULL);
}
m_outside.clear();
m_transit.clear();
m_doing_task.clear();
}
Director::~Director()
{
}
void Director::request_task(Actor* requestee)
{
bool permission = false;
unsigned int task_value = 0;
permission = task_permission(requestee->state_check());
if (permission == true)
{
task_value = generate_random_task(requestee->Get_age(), world_time);
int tile_number = std::get<2>(requestee->Get_Location());
auto [location, building] = public_task_setup(tile_number, (Tasks::Destination_Types)task_value);
int task_length = Random::random_number(20, 300, {});
if (building == NULL || building->closed == true)
{
int num = Random::random_number(0, 1, {});
if (num == 1)
{
go_home(requestee);
}
}
else
{
Task* task = new Task;
task->destination = (Tasks::Destination_Types)task_value;
task->location_type = { building, NULL, NULL, NULL, NULL };
task->location = location;
task->task_length = task_length;
if (building->assigned_tasks >= building->Get_capacity() + 1)
{
delete task;
int num = Random::random_number(0, 1, {});
if (num == 1)
{
go_home(requestee);
}
}
else
{
building->assigned_tasks = building->assigned_tasks + 1;
m_current_tasks.push_back({ task, requestee, 0 });
requestee->set_state(Actor::waiting);
}
}
}
}
void Director::go_home(Actor* requestee)
{
Task* task = new Task;
task->location_type = { NULL, NULL, NULL, requestee->Home, NULL };
task->location = requestee->House_Location();
requestee->set_state(Actor::waiting);
m_current_tasks.push_back({ task, requestee, 0});
}
| 27.62117 | 207 | 0.636799 | bptigg |
29ad11fbfd2e7730c78c35718fb734dac1628d67 | 1,124 | hpp | C++ | Firmware/src/application/launchpad/LcdGui.hpp | zukaitis/midi-grid | 527ad37348983f481511fef52d1645eab3a2f60e | [
"BSD-3-Clause"
] | 59 | 2018-03-17T10:32:48.000Z | 2022-03-19T17:59:29.000Z | Firmware/src/application/launchpad/LcdGui.hpp | zukaitis/midi-grid | 527ad37348983f481511fef52d1645eab3a2f60e | [
"BSD-3-Clause"
] | 3 | 2019-11-12T09:49:59.000Z | 2020-12-09T11:55:00.000Z | Firmware/src/application/launchpad/LcdGui.hpp | zukaitis/midi-grid | 527ad37348983f481511fef52d1645eab3a2f60e | [
"BSD-3-Clause"
] | 10 | 2019-03-14T22:53:39.000Z | 2021-12-26T13:42:20.000Z | #ifndef APPLICATION_LAUNCHPAD_LCD_GUI_HPP_
#define APPLICATION_LAUNCHPAD_LCD_GUI_HPP_
#include <stdint.h>
namespace lcd
{
class LcdInterface;
}
namespace application
{
namespace launchpad
{
struct TimedDisplay
{
bool isOn;
uint32_t timeToDisable;
};
class Launchpad;
class LcdGui
{
public:
LcdGui( Launchpad& launchpad, lcd::LcdInterface& lcd );
void initialize();
void refresh();
void registerMidiInputActivity();
void registerMidiOutputActivity();
void displayRotaryControlValues();
static const int16_t refreshPeriodMs = 250;
private:
void refreshStatusBar();
void refreshMainArea();
void displayLaunchpad95Info();
void displayClipName();
void displayDeviceName();
void displayTrackName();
void displayMode();
void displaySubmode();
void displayStatus();
void displayTimingStatus();
Launchpad& launchpad_;
lcd::LcdInterface& lcd_;
TimedDisplay midiInputActivityIcon_;
TimedDisplay midiOutputActivityIcon_;
TimedDisplay rotaryControlValues_;
};
}
} // namespace
#endif // APPLICATION_LAUNCHPAD_LCD_GUI_HPP_
| 17.84127 | 59 | 0.732206 | zukaitis |
29ae839a125c655da171de74a411fa9c261d85be | 1,544 | cpp | C++ | buildcc/lib/target/src/target/pch.cpp | d-winsor/build_in_cpp | 581c827fd8c69a7258175e360847676861a5c7b0 | [
"Apache-2.0"
] | null | null | null | buildcc/lib/target/src/target/pch.cpp | d-winsor/build_in_cpp | 581c827fd8c69a7258175e360847676861a5c7b0 | [
"Apache-2.0"
] | null | null | null | buildcc/lib/target/src/target/pch.cpp | d-winsor/build_in_cpp | 581c827fd8c69a7258175e360847676861a5c7b0 | [
"Apache-2.0"
] | null | null | null | /*
* Copyright 2021 Niket Naidu. 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 "target/target.h"
namespace buildcc::base {
void Target::AddPchAbsolute(const fs::path &absolute_filepath) {
LockedAfterBuild();
const auto file_ext_type = ext_.GetType(absolute_filepath);
env::assert_fatal(FileExt::IsValidHeader(file_ext_type),
fmt::format("{} does not have a valid header extension",
absolute_filepath.string()));
state_.contains_pch = true;
const fs::path absolute_pch = fs::path(absolute_filepath).make_preferred();
storer_.current_pch_files.user.insert(absolute_pch);
}
void Target::AddPch(const fs::path &relative_filename,
const fs::path &relative_to_target_path) {
env::log_trace(name_, __FUNCTION__);
// Compute the absolute source path
fs::path absolute_pch =
target_root_dir_ / relative_to_target_path / relative_filename;
AddPchAbsolute(absolute_pch);
}
} // namespace buildcc::base
| 34.311111 | 77 | 0.718264 | d-winsor |
29aecab0fdaff757970b13b0bd7f3aa78af863a6 | 1,063 | cpp | C++ | Solution/PhoenixEngine/Source/GameObject/GameObject.cpp | rohunb/PhoenixEngine | 4d21f9000c2e0c553c398785e8cebff1bc190a8c | [
"MIT"
] | 2 | 2017-11-09T20:05:36.000Z | 2018-07-05T00:55:01.000Z | Solution/PhoenixEngine/Source/GameObject/GameObject.cpp | rohunb/PhoenixEngine | 4d21f9000c2e0c553c398785e8cebff1bc190a8c | [
"MIT"
] | null | null | null | Solution/PhoenixEngine/Source/GameObject/GameObject.cpp | rohunb/PhoenixEngine | 4d21f9000c2e0c553c398785e8cebff1bc190a8c | [
"MIT"
] | null | null | null | #include "Stdafx.h"
#include "GameObject/GameObject.h"
#include "Core/GameScene.h"
using namespace Phoenix;
FGameObject::FGameObject()
{
}
FGameObject::FGameObject(FGameScene& inGameScene, ID inId) :
Id(inId),
GameScene(&inGameScene)
{
}
FGameObject::~FGameObject()
{
}
void FGameObject::AddComponent(BaseComponent* inComponent, TypeId inComponentTypeId)
{
GameScene->GameObjectAttributes.Storage.AddComponent(this, inComponent, inComponentTypeId);
}
const FGameObject::ID& FGameObject::GetId() const
{
return Id;
}
BaseComponent& FGameObject::GetComponent(TypeId InTypeId) const
{
return GameScene->GameObjectAttributes.Storage.GetComponent(*this, InTypeId);
}
void FGameObject::SetActive(const bool InActive)
{
GameScene->ActivateGameObject(*this, InActive);
}
bool FGameObject::operator==(const FGameObject& GameObject) const
{
return Id == GameObject.Id && GameObject.GameScene == GameScene;
}
void FGameObject::RemoveComponent(TypeId InComponentTypeId)
{
GameScene->GameObjectAttributes.Storage.RemoveComponent(*this, InComponentTypeId);
}
| 21.26 | 92 | 0.78269 | rohunb |
29c1f3878fccdf48b72819cb6e9fa27b979d86af | 822 | hh | C++ | regression_tests/files_keeper_for_regression_tests.hh | WRCIECH/clang-pimpl | 2094d9c7a96de5c7bc06b18022ecbb14901345ce | [
"Apache-2.0"
] | null | null | null | regression_tests/files_keeper_for_regression_tests.hh | WRCIECH/clang-pimpl | 2094d9c7a96de5c7bc06b18022ecbb14901345ce | [
"Apache-2.0"
] | null | null | null | regression_tests/files_keeper_for_regression_tests.hh | WRCIECH/clang-pimpl | 2094d9c7a96de5c7bc06b18022ecbb14901345ce | [
"Apache-2.0"
] | null | null | null | #pragma once
#include "compilation_pack.hh"
#include "refactor_adapter/files_keeper.hh"
#include "clang/Tooling/CommonOptionsParser.h"
#include <memory>
class FilesKeeperForRegressionTests : public FilesKeeper {
public:
FilesKeeperForRegressionTests(
CompilationPack *pack, std::shared_ptr<OptionsAdapter> options_adapter);
static std::unique_ptr<FilesKeeperForRegressionTests>
create(CompilationPack *pack,
std::shared_ptr<OptionsAdapter> options_adapter);
bool isOk() override;
llvm::Error getError() override;
const std::vector<std::string> *getSourcePathList() override;
clang::tooling::CompilationDatabase *getCompilations() override;
bool isInplace() const override;
private:
std::unique_ptr<clang::tooling::CompilationDatabase> compilation_database_;
CompilationPack *pack_;
}; | 34.25 | 78 | 0.787105 | WRCIECH |
29c2baca261bfa762c0bc3ebc4bad9046caee636 | 3,691 | cpp | C++ | lib/Transforms/LoopInterchange.cpp | brightlaboratory/mlir | 23ec2164e1bb1bdfbba5eb0c4e1f8a58d1c71d22 | [
"Apache-2.0"
] | null | null | null | lib/Transforms/LoopInterchange.cpp | brightlaboratory/mlir | 23ec2164e1bb1bdfbba5eb0c4e1f8a58d1c71d22 | [
"Apache-2.0"
] | null | null | null | lib/Transforms/LoopInterchange.cpp | brightlaboratory/mlir | 23ec2164e1bb1bdfbba5eb0c4e1f8a58d1c71d22 | [
"Apache-2.0"
] | null | null | null | //===- LoopInterchange.cpp - Code to perform loop interchange --------------------===//
//
// Copyright 2019 The MLIR 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.
// =============================================================================
//
// This file implements loop unrolling.
//
//===----------------------------------------------------------------------===//
#include "mlir/Transforms/Passes.h"
#include "mlir/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/AffineOps/AffineOps.h"
#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/IR/Builders.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/LoopUtils.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include <iostream>
using namespace mlir;
using namespace std;
#define DEBUG_TYPE "affine-loop-interchange"
static llvm::cl::OptionCategory clOptionsCategory(DEBUG_TYPE " options");
namespace {
struct LoopInterchange : public FunctionPass<LoopInterchange> {
void runOnFunction() override;
/// Unroll this for op. Returns failure if nothing was done.
LogicalResult runOnAffineForOp(AffineForOp forOp);
};
} // end anonymous namespace
void LoopInterchange::runOnFunction() {
cout << "In LoopInterchange's runOnFunction()" << endl;
// Gathers all innermost loops through a post order pruned walk.
struct InnermostLoopGatherer {
// Store innermost loops as we walk.
std::vector<AffineForOp> loops;
void walkPostOrder(FuncOp f) {
for (auto &b : f)
walkPostOrder(b.begin(), b.end());
}
bool walkPostOrder(Block::iterator Start, Block::iterator End) {
bool hasInnerLoops = false;
// We need to walk all elements since all innermost loops need to be
// gathered as opposed to determining whether this list has any inner
// loops or not.
while (Start != End)
hasInnerLoops |= walkPostOrder(&(*Start++));
return hasInnerLoops;
}
bool walkPostOrder(Operation *opInst) {
bool hasInnerLoops = false;
for (auto ®ion : opInst->getRegions())
for (auto &block : region)
hasInnerLoops |= walkPostOrder(block.begin(), block.end());
if (isa<AffineForOp>(opInst)) {
if (!hasInnerLoops)
loops.push_back(cast<AffineForOp>(opInst));
return true;
}
return hasInnerLoops;
}
};
{
// Store short loops as we walk.
std::vector<AffineForOp> loops;
getFunction().walk([&](AffineForOp forOp) {
loops.push_back(forOp);
});
if (loops.size() >= 2) {
interchangeLoops(loops.at(1), loops.at(0));
}
return;
}
}
/// Unrolls a 'affine.for' op. Returns success if the loop was unrolled,
/// failure otherwise. The default unroll factor is 4.
LogicalResult LoopInterchange::runOnAffineForOp(AffineForOp forOp) {
cout << "In LoopInterchange's runOnAffineForOp()" << endl;
return success();
}
std::unique_ptr<OpPassBase<FuncOp>> mlir::createLoopInterchangePass() {
return std::make_unique<LoopInterchange>();
}
static PassRegistration<LoopInterchange> pass("affine-loop-interchange", "Interchange loops");
| 31.818966 | 95 | 0.662693 | brightlaboratory |
29c4997a171b1d5ebec67eeeabd72d8d52824897 | 163,903 | inl | C++ | code/extlibs/Effects11/EffectVariable.inl | gscept/nebula-trifid | e7c0a0acb05eedad9ed37a72c1bdf2d658511b42 | [
"BSD-2-Clause"
] | 67 | 2015-03-30T19:56:16.000Z | 2022-03-11T13:52:17.000Z | code/extlibs/Effects11/EffectVariable.inl | gscept/nebula-trifid | e7c0a0acb05eedad9ed37a72c1bdf2d658511b42 | [
"BSD-2-Clause"
] | 5 | 2015-04-15T17:17:33.000Z | 2016-02-11T00:40:17.000Z | code/extlibs/Effects11/EffectVariable.inl | gscept/nebula-trifid | e7c0a0acb05eedad9ed37a72c1bdf2d658511b42 | [
"BSD-2-Clause"
] | 34 | 2015-03-30T15:08:00.000Z | 2021-09-23T05:55:10.000Z | //////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) Microsoft Corporation. All Rights Reserved.
//
// File: EffectVariable.inl
// Content: D3DX11 Effects Variable reflection template
// These templates define the many Effect variable types.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// Invalid variable forward defines
//////////////////////////////////////////////////////////////////////////
struct SEffectInvalidScalarVariable;
struct SEffectInvalidVectorVariable;
struct SEffectInvalidMatrixVariable;
struct SEffectInvalidStringVariable;
struct SEffectInvalidClassInstanceVariable;
struct SEffectInvalidInterfaceVariable;
struct SEffectInvalidShaderResourceVariable;
struct SEffectInvalidUnorderedAccessViewVariable;
struct SEffectInvalidRenderTargetViewVariable;
struct SEffectInvalidDepthStencilViewVariable;
struct SEffectInvalidConstantBuffer;
struct SEffectInvalidShaderVariable;
struct SEffectInvalidBlendVariable;
struct SEffectInvalidDepthStencilVariable;
struct SEffectInvalidRasterizerVariable;
struct SEffectInvalidSamplerVariable;
struct SEffectInvalidTechnique;
struct SEffectInvalidPass;
struct SEffectInvalidType;
extern SEffectInvalidScalarVariable g_InvalidScalarVariable;
extern SEffectInvalidVectorVariable g_InvalidVectorVariable;
extern SEffectInvalidMatrixVariable g_InvalidMatrixVariable;
extern SEffectInvalidStringVariable g_InvalidStringVariable;
extern SEffectInvalidClassInstanceVariable g_InvalidClassInstanceVariable;
extern SEffectInvalidInterfaceVariable g_InvalidInterfaceVariable;
extern SEffectInvalidShaderResourceVariable g_InvalidShaderResourceVariable;
extern SEffectInvalidUnorderedAccessViewVariable g_InvalidUnorderedAccessViewVariable;
extern SEffectInvalidRenderTargetViewVariable g_InvalidRenderTargetViewVariable;
extern SEffectInvalidDepthStencilViewVariable g_InvalidDepthStencilViewVariable;
extern SEffectInvalidConstantBuffer g_InvalidConstantBuffer;
extern SEffectInvalidShaderVariable g_InvalidShaderVariable;
extern SEffectInvalidBlendVariable g_InvalidBlendVariable;
extern SEffectInvalidDepthStencilVariable g_InvalidDepthStencilVariable;
extern SEffectInvalidRasterizerVariable g_InvalidRasterizerVariable;
extern SEffectInvalidSamplerVariable g_InvalidSamplerVariable;
extern SEffectInvalidTechnique g_InvalidTechnique;
extern SEffectInvalidPass g_InvalidPass;
extern SEffectInvalidType g_InvalidType;
enum ETemplateVarType
{
ETVT_Bool,
ETVT_Int,
ETVT_Float
};
//////////////////////////////////////////////////////////////////////////
// Invalid effect variable struct definitions
//////////////////////////////////////////////////////////////////////////
struct SEffectInvalidType : public ID3DX11EffectType
{
STDMETHOD_(BOOL, IsValid)() { return FALSE; }
STDMETHOD(GetDesc)(D3DX11_EFFECT_TYPE_DESC *pDesc) { return E_FAIL; }
STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(UINT Index) { return &g_InvalidType; }
STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name) { return &g_InvalidType; }
STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semanti) { return &g_InvalidType; }
STDMETHOD_(LPCSTR, GetMemberName)(UINT Index) { return NULL; }
STDMETHOD_(LPCSTR, GetMemberSemantic)(UINT Index) { return NULL; }
};
template<typename IBaseInterface>
struct TEffectInvalidVariable : public IBaseInterface
{
public:
STDMETHOD_(BOOL, IsValid)() { return FALSE; }
STDMETHOD_(ID3DX11EffectType*, GetType)() { return &g_InvalidType; }
STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc) { return E_FAIL; }
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(UINT Index) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(LPCSTR Name) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(LPCSTR Semantic) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectVariable*, GetElement)(UINT Index) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)() { return &g_InvalidConstantBuffer; }
STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)() { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)() { return &g_InvalidVectorVariable; }
STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)() { return &g_InvalidMatrixVariable; }
STDMETHOD_(ID3DX11EffectStringVariable*, AsString)() { return &g_InvalidStringVariable; }
STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)() { return &g_InvalidClassInstanceVariable; }
STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)() { return &g_InvalidInterfaceVariable; }
STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)() { return &g_InvalidShaderResourceVariable; }
STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)() { return &g_InvalidUnorderedAccessViewVariable; }
STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)() { return &g_InvalidRenderTargetViewVariable; }
STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)() { return &g_InvalidDepthStencilViewVariable; }
STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)() { return &g_InvalidConstantBuffer; }
STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)() { return &g_InvalidShaderVariable; }
STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)() { return &g_InvalidBlendVariable; }
STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)() { return &g_InvalidDepthStencilVariable; }
STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)() { return &g_InvalidRasterizerVariable; }
STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)() { return &g_InvalidSamplerVariable; }
STDMETHOD(SetRawValue)(CONST void *pData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetRawValue)(void *pData, UINT Offset, UINT Count) { return E_FAIL; }
};
struct SEffectInvalidScalarVariable : public TEffectInvalidVariable<ID3DX11EffectScalarVariable>
{
public:
STDMETHOD(SetFloat)(CONST float Value) { return E_FAIL; }
STDMETHOD(GetFloat)(float *pValue) { return E_FAIL; }
STDMETHOD(SetFloatArray)(CONST float *pData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetFloatArray)(float *pData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(SetInt)(CONST int Value) { return E_FAIL; }
STDMETHOD(GetInt)(int *pValue) { return E_FAIL; }
STDMETHOD(SetIntArray)(CONST int *pData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetIntArray)(int *pData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(SetBool)(CONST BOOL Value) { return E_FAIL; }
STDMETHOD(GetBool)(BOOL *pValue) { return E_FAIL; }
STDMETHOD(SetBoolArray)(CONST BOOL *pData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetBoolArray)(BOOL *pData, UINT Offset, UINT Count) { return E_FAIL; }
};
struct SEffectInvalidVectorVariable : public TEffectInvalidVariable<ID3DX11EffectVectorVariable>
{
public:
STDMETHOD(SetFloatVector)(CONST float *pData) { return E_FAIL; };
STDMETHOD(SetIntVector)(CONST int *pData) { return E_FAIL; };
STDMETHOD(SetBoolVector)(CONST BOOL *pData) { return E_FAIL; };
STDMETHOD(GetFloatVector)(float *pData) { return E_FAIL; };
STDMETHOD(GetIntVector)(int *pData) { return E_FAIL; };
STDMETHOD(GetBoolVector)(BOOL *pData) { return E_FAIL; };
STDMETHOD(SetBoolVectorArray) (CONST BOOL *pData, UINT Offset, UINT Count) { return E_FAIL; };
STDMETHOD(SetIntVectorArray) (CONST int *pData, UINT Offset, UINT Count) { return E_FAIL; };
STDMETHOD(SetFloatVectorArray)(CONST float *pData, UINT Offset, UINT Count) { return E_FAIL; };
STDMETHOD(GetBoolVectorArray) (BOOL *pData, UINT Offset, UINT Count) { return E_FAIL; };
STDMETHOD(GetIntVectorArray) (int *pData, UINT Offset, UINT Count) { return E_FAIL; };
STDMETHOD(GetFloatVectorArray)(float *pData, UINT Offset, UINT Count) { return E_FAIL; };
};
struct SEffectInvalidMatrixVariable : public TEffectInvalidVariable<ID3DX11EffectMatrixVariable>
{
public:
STDMETHOD(SetMatrix)(CONST float *pData) { return E_FAIL; }
STDMETHOD(GetMatrix)(float *pData) { return E_FAIL; }
STDMETHOD(SetMatrixArray)(CONST float *pData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetMatrixArray)(float *pData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(SetMatrixPointerArray)(CONST float **ppData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetMatrixPointerArray)(float **ppData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(SetMatrixTranspose)(CONST float *pData) { return E_FAIL; }
STDMETHOD(GetMatrixTranspose)(float *pData) { return E_FAIL; }
STDMETHOD(SetMatrixTransposeArray)(CONST float *pData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetMatrixTransposeArray)(float *pData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(SetMatrixTransposePointerArray)(CONST float **ppData, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetMatrixTransposePointerArray)(float **ppData, UINT Offset, UINT Count) { return E_FAIL; }
};
struct SEffectInvalidStringVariable : public TEffectInvalidVariable<ID3DX11EffectStringVariable>
{
public:
STDMETHOD(GetString)(LPCSTR *ppString) { return E_FAIL; }
STDMETHOD(GetStringArray)(LPCSTR *ppStrings, UINT Offset, UINT Count) { return E_FAIL; }
};
struct SEffectInvalidClassInstanceVariable : public TEffectInvalidVariable<ID3DX11EffectClassInstanceVariable>
{
public:
STDMETHOD(GetClassInstance)(ID3D11ClassInstance **ppClassInstance) { return E_FAIL; }
};
struct SEffectInvalidInterfaceVariable : public TEffectInvalidVariable<ID3DX11EffectInterfaceVariable>
{
public:
STDMETHOD(SetClassInstance)(ID3DX11EffectClassInstanceVariable *pEffectClassInstance) { return E_FAIL; }
STDMETHOD(GetClassInstance)(ID3DX11EffectClassInstanceVariable **ppEffectClassInstance) { return E_FAIL; }
};
struct SEffectInvalidShaderResourceVariable : public TEffectInvalidVariable<ID3DX11EffectShaderResourceVariable>
{
public:
STDMETHOD(SetResource)(ID3D11ShaderResourceView *pResource) { return E_FAIL; }
STDMETHOD(GetResource)(ID3D11ShaderResourceView **ppResource) { return E_FAIL; }
STDMETHOD(SetResourceArray)(ID3D11ShaderResourceView **ppResources, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetResourceArray)(ID3D11ShaderResourceView **ppResources, UINT Offset, UINT Count) { return E_FAIL; }
};
struct SEffectInvalidUnorderedAccessViewVariable : public TEffectInvalidVariable<ID3DX11EffectUnorderedAccessViewVariable>
{
public:
STDMETHOD(SetUnorderedAccessView)(ID3D11UnorderedAccessView *pResource) { return E_FAIL; }
STDMETHOD(GetUnorderedAccessView)(ID3D11UnorderedAccessView **ppResource) { return E_FAIL; }
STDMETHOD(SetUnorderedAccessViewArray)(ID3D11UnorderedAccessView **ppResources, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetUnorderedAccessViewArray)(ID3D11UnorderedAccessView **ppResources, UINT Offset, UINT Count) { return E_FAIL; }
};
struct SEffectInvalidRenderTargetViewVariable : public TEffectInvalidVariable<ID3DX11EffectRenderTargetViewVariable>
{
public:
STDMETHOD(SetRenderTarget)(ID3D11RenderTargetView *pResource) { return E_FAIL; }
STDMETHOD(GetRenderTarget)(ID3D11RenderTargetView **ppResource) { return E_FAIL; }
STDMETHOD(SetRenderTargetArray)(ID3D11RenderTargetView **ppResources, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetRenderTargetArray)(ID3D11RenderTargetView **ppResources, UINT Offset, UINT Count) { return E_FAIL; }
};
struct SEffectInvalidDepthStencilViewVariable : public TEffectInvalidVariable<ID3DX11EffectDepthStencilViewVariable>
{
public:
STDMETHOD(SetDepthStencil)(ID3D11DepthStencilView *pResource) { return E_FAIL; }
STDMETHOD(GetDepthStencil)(ID3D11DepthStencilView **ppResource) { return E_FAIL; }
STDMETHOD(SetDepthStencilArray)(ID3D11DepthStencilView **ppResources, UINT Offset, UINT Count) { return E_FAIL; }
STDMETHOD(GetDepthStencilArray)(ID3D11DepthStencilView **ppResources, UINT Offset, UINT Count) { return E_FAIL; }
};
struct SEffectInvalidConstantBuffer : public TEffectInvalidVariable<ID3DX11EffectConstantBuffer>
{
public:
STDMETHOD(SetConstantBuffer)(ID3D11Buffer *pConstantBuffer) { return E_FAIL; }
STDMETHOD(GetConstantBuffer)(ID3D11Buffer **ppConstantBuffer) { return E_FAIL; }
STDMETHOD(UndoSetConstantBuffer)() { return E_FAIL; }
STDMETHOD(SetTextureBuffer)(ID3D11ShaderResourceView *pTextureBuffer) { return E_FAIL; }
STDMETHOD(GetTextureBuffer)(ID3D11ShaderResourceView **ppTextureBuffer) { return E_FAIL; }
STDMETHOD(UndoSetTextureBuffer)() { return E_FAIL; }
};
struct SEffectInvalidShaderVariable : public TEffectInvalidVariable<ID3DX11EffectShaderVariable>
{
public:
STDMETHOD(GetShaderDesc)(UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc) { return E_FAIL; }
STDMETHOD(GetVertexShader)(UINT ShaderIndex, ID3D11VertexShader **ppVS) { return E_FAIL; }
STDMETHOD(GetGeometryShader)(UINT ShaderIndex, ID3D11GeometryShader **ppGS) { return E_FAIL; }
STDMETHOD(GetPixelShader)(UINT ShaderIndex, ID3D11PixelShader **ppPS) { return E_FAIL; }
STDMETHOD(GetHullShader)(UINT ShaderIndex, ID3D11HullShader **ppPS) { return E_FAIL; }
STDMETHOD(GetDomainShader)(UINT ShaderIndex, ID3D11DomainShader **ppPS) { return E_FAIL; }
STDMETHOD(GetComputeShader)(UINT ShaderIndex, ID3D11ComputeShader **ppPS) { return E_FAIL; }
STDMETHOD(GetInputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc) { return E_FAIL; }
STDMETHOD(GetOutputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc) { return E_FAIL; }
STDMETHOD(GetPatchConstantSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc) { return E_FAIL; }
};
struct SEffectInvalidBlendVariable : public TEffectInvalidVariable<ID3DX11EffectBlendVariable>
{
public:
STDMETHOD(GetBlendState)(UINT Index, ID3D11BlendState **ppBlendState) { return E_FAIL; }
STDMETHOD(SetBlendState)(UINT Index, ID3D11BlendState *pBlendState) { return E_FAIL; }
STDMETHOD(UndoSetBlendState)(UINT Index) { return E_FAIL; }
STDMETHOD(GetBackingStore)(UINT Index, D3D11_BLEND_DESC *pBlendDesc) { return E_FAIL; }
};
struct SEffectInvalidDepthStencilVariable : public TEffectInvalidVariable<ID3DX11EffectDepthStencilVariable>
{
public:
STDMETHOD(GetDepthStencilState)(UINT Index, ID3D11DepthStencilState **ppDepthStencilState) { return E_FAIL; }
STDMETHOD(SetDepthStencilState)(UINT Index, ID3D11DepthStencilState *pDepthStencilState) { return E_FAIL; }
STDMETHOD(UndoSetDepthStencilState)(UINT Index) { return E_FAIL; }
STDMETHOD(GetBackingStore)(UINT Index, D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc) { return E_FAIL; }
};
struct SEffectInvalidRasterizerVariable : public TEffectInvalidVariable<ID3DX11EffectRasterizerVariable>
{
public:
STDMETHOD(GetRasterizerState)(UINT Index, ID3D11RasterizerState **ppRasterizerState) { return E_FAIL; }
STDMETHOD(SetRasterizerState)(UINT Index, ID3D11RasterizerState *pRasterizerState) { return E_FAIL; }
STDMETHOD(UndoSetRasterizerState)(UINT Index) { return E_FAIL; }
STDMETHOD(GetBackingStore)(UINT Index, D3D11_RASTERIZER_DESC *pRasterizerDesc) { return E_FAIL; }
};
struct SEffectInvalidSamplerVariable : public TEffectInvalidVariable<ID3DX11EffectSamplerVariable>
{
public:
STDMETHOD(GetSampler)(UINT Index, ID3D11SamplerState **ppSampler) { return E_FAIL; }
STDMETHOD(SetSampler)(UINT Index, ID3D11SamplerState *pSampler) { return E_FAIL; }
STDMETHOD(UndoSetSampler)(UINT Index) { return E_FAIL; }
STDMETHOD(GetBackingStore)(UINT Index, D3D11_SAMPLER_DESC *pSamplerDesc) { return E_FAIL; }
};
struct SEffectInvalidPass : public ID3DX11EffectPass
{
public:
STDMETHOD_(BOOL, IsValid)() { return FALSE; }
STDMETHOD(GetDesc)(D3DX11_PASS_DESC *pDesc) { return E_FAIL; }
STDMETHOD(GetVertexShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
STDMETHOD(GetGeometryShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
STDMETHOD(GetPixelShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
STDMETHOD(GetHullShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
STDMETHOD(GetDomainShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
STDMETHOD(GetComputeShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name) { return &g_InvalidScalarVariable; }
STDMETHOD(Apply)(UINT Flags, ID3D11DeviceContext* pContext) { return E_FAIL; }
STDMETHOD(Commit)(ID3D11DeviceContext* pContext) { return E_FAIL; }
STDMETHOD(ComputeStateBlockMask)(D3DX11_STATE_BLOCK_MASK *pStateBlockMask) { return E_FAIL; }
};
struct SEffectInvalidTechnique : public ID3DX11EffectTechnique
{
public:
STDMETHOD_(BOOL, IsValid)() { return FALSE; }
STDMETHOD(GetDesc)(D3DX11_TECHNIQUE_DESC *pDesc) { return E_FAIL; }
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectPass*, GetPassByIndex)(UINT Index) { return &g_InvalidPass; }
STDMETHOD_(ID3DX11EffectPass*, GetPassByName)(LPCSTR Name) { return &g_InvalidPass; }
STDMETHOD(ComputeStateBlockMask)(D3DX11_STATE_BLOCK_MASK *pStateBlockMask) { return E_FAIL; }
};
struct SEffectInvalidGroup : public ID3DX11EffectGroup
{
public:
STDMETHOD_(BOOL, IsValid)() { return FALSE; }
STDMETHOD(GetDesc)(D3DX11_GROUP_DESC *pDesc) { return E_FAIL; }
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name) { return &g_InvalidScalarVariable; }
STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(UINT Index) { return &g_InvalidTechnique; }
STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(LPCSTR Name) { return &g_InvalidTechnique; }
};
//////////////////////////////////////////////////////////////////////////
// Helper routines
//////////////////////////////////////////////////////////////////////////
// This is an annoying warning that pops up in retail builds because
// the code that jumps to "lExit" is conditionally not compiled.
// The only alternative is more #ifdefs in every function
#pragma warning( disable : 4102 ) // 'label' : unreferenced label
#define VERIFYPARAMETER(x) \
{ if (!(x)) { DPF(0, "%s: Parameter " #x " was NULL.", pFuncName); \
__BREAK_ON_FAIL; hr = E_INVALIDARG; goto lExit; } }
static HRESULT AnnotationInvalidSetCall(LPCSTR pFuncName)
{
DPF(0, "%s: Annotations are readonly", pFuncName);
return D3DERR_INVALIDCALL;
}
static HRESULT ObjectSetRawValue()
{
DPF(0, "ID3DX11EffectVariable::SetRawValue: Objects do not support ths call; please use the specific object accessors instead.");
return D3DERR_INVALIDCALL;
}
static HRESULT ObjectGetRawValue()
{
DPF(0, "ID3DX11EffectVariable::GetRawValue: Objects do not support ths call; please use the specific object accessors instead.");
return D3DERR_INVALIDCALL;
}
ID3DX11EffectConstantBuffer * NoParentCB();
ID3DX11EffectVariable * GetAnnotationByIndexHelper(const char *pClassName, UINT Index, UINT AnnotationCount, SAnnotation *pAnnotations);
ID3DX11EffectVariable * GetAnnotationByNameHelper(const char *pClassName, LPCSTR Name, UINT AnnotationCount, SAnnotation *pAnnotations);
template<typename SVarType>
BOOL GetVariableByIndexHelper(UINT Index, UINT VariableCount, SVarType *pVariables,
BYTE *pBaseAddress, SVarType **ppMember, void **ppDataPtr)
{
LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberByIndex";
if (Index >= VariableCount)
{
DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, VariableCount);
return FALSE;
}
*ppMember = pVariables + Index;
*ppDataPtr = pBaseAddress + (*ppMember)->Data.Offset;
return TRUE;
}
template<typename SVarType>
BOOL GetVariableByNameHelper(LPCSTR Name, UINT VariableCount, SVarType *pVariables,
BYTE *pBaseAddress, SVarType **ppMember, void **ppDataPtr, UINT* pIndex)
{
LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberByName";
if (NULL == Name)
{
DPF(0, "%s: Parameter Name was NULL.", pFuncName);
return FALSE;
}
UINT i;
bool bHasSuper = false;
for (i = 0; i < VariableCount; ++ i)
{
*ppMember = pVariables + i;
D3DXASSERT(NULL != (*ppMember)->pName);
if (strcmp((*ppMember)->pName, Name) == 0)
{
*ppDataPtr = pBaseAddress + (*ppMember)->Data.Offset;
*pIndex = i;
return TRUE;
}
else if (i == 0 &&
(*ppMember)->pName[0] == '$' &&
strcmp((*ppMember)->pName, "$super") == 0)
{
bHasSuper = true;
}
}
if (bHasSuper)
{
SVarType* pSuper = pVariables;
return GetVariableByNameHelper<SVarType>(Name,
pSuper->pType->StructType.Members,
(SVarType*)pSuper->pType->StructType.pMembers,
pBaseAddress + pSuper->Data.Offset,
ppMember,
ppDataPtr,
pIndex);
}
DPF(0, "%s: Variable [%s] not found", pFuncName, Name);
return FALSE;
}
template<typename SVarType>
BOOL GetVariableBySemanticHelper(LPCSTR Semantic, UINT VariableCount, SVarType *pVariables,
BYTE *pBaseAddress, SVarType **ppMember, void **ppDataPtr, UINT* pIndex)
{
LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberBySemantic";
if (NULL == Semantic)
{
DPF(0, "%s: Parameter Semantic was NULL.", pFuncName);
return FALSE;
}
UINT i;
for (i = 0; i < VariableCount; ++ i)
{
*ppMember = pVariables + i;
if (NULL != (*ppMember)->pSemantic &&
_stricmp((*ppMember)->pSemantic, Semantic) == 0)
{
*ppDataPtr = pBaseAddress + (*ppMember)->Data.Offset;
*pIndex = i;
return TRUE;
}
}
DPF(0, "%s: Variable with semantic [%s] not found", pFuncName, Semantic);
return FALSE;
}
D3DX11INLINE BOOL AreBoundsValid(UINT Offset, UINT Count, CONST void *pData, CONST SType *pType, UINT TotalUnpackedSize)
{
if (Count == 0) return TRUE;
UINT singleElementSize = pType->GetTotalUnpackedSize(TRUE);
D3DXASSERT(singleElementSize <= pType->Stride);
return ((Offset + Count >= Offset) &&
((Offset + Count) < ((UINT)-1) / pType->Stride) &&
(Count * pType->Stride + (BYTE*)pData >= (BYTE*)pData) &&
((Offset + Count - 1) * pType->Stride + singleElementSize <= TotalUnpackedSize));
}
// Note that the branches in this code is based on template parameters and will be compiled out
template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, BOOL ValidatePtr>
__forceinline HRESULT CopyScalarValue(SRC_TYPE SrcValue, void *pDest, const char *pFuncName)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
if (ValidatePtr)
VERIFYPARAMETER(pDest);
#endif
switch (SourceType)
{
case ETVT_Bool:
switch (DestType)
{
case ETVT_Bool:
*(int*)pDest = (SrcValue != 0) ? -1 : 0;
break;
case ETVT_Int:
*(int*)pDest = SrcValue ? 1 : 0;
break;
case ETVT_Float:
*(float*)pDest = SrcValue ? 1.0f : 0.0f;
break;
default:
D3DXASSERT(0);
}
break;
case ETVT_Int:
switch (DestType)
{
case ETVT_Bool:
*(int*)pDest = (SrcValue != 0) ? -1 : 0;
break;
case ETVT_Int:
*(int*)pDest = (int) SrcValue;
break;
case ETVT_Float:
*(float*)pDest = (float)(SrcValue);
break;
default:
D3DXASSERT(0);
}
break;
case ETVT_Float:
switch (DestType)
{
case ETVT_Bool:
*(int*)pDest = (SrcValue != 0.0f) ? -1 : 0;
break;
case ETVT_Int:
*(int*)pDest = (int) (SrcValue);
break;
case ETVT_Float:
*(float*)pDest = (float) SrcValue;
break;
default:
D3DXASSERT(0);
}
break;
default:
D3DXASSERT(0);
}
lExit:
return S_OK;
}
template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, typename DEST_TYPE>
D3DX11INLINE HRESULT SetScalarArray(CONST SRC_TYPE *pSrcValues, DEST_TYPE *pDestValues, UINT Offset, UINT Count,
SType *pType, UINT TotalUnpackedSize, const char *pFuncName)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
VERIFYPARAMETER(pSrcValues);
if (!AreBoundsValid(Offset, Count, pSrcValues, pType, TotalUnpackedSize))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
UINT i, j, delta = pType->NumericType.IsPackedArray ? 1 : SType::c_ScalarsPerRegister;
pDestValues += Offset * delta;
for (i = 0, j = 0; j < Count; i += delta, ++ j)
{
// pDestValues[i] = (DEST_TYPE)pSrcValues[j];
CopyScalarValue<SourceType, DestType, SRC_TYPE, FALSE>(pSrcValues[j], &pDestValues[i], "SetScalarArray");
}
lExit:
return hr;
}
template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, typename DEST_TYPE>
D3DX11INLINE HRESULT GetScalarArray(SRC_TYPE *pSrcValues, DEST_TYPE *pDestValues, UINT Offset, UINT Count,
SType *pType, UINT TotalUnpackedSize, const char *pFuncName)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
VERIFYPARAMETER(pDestValues);
if (!AreBoundsValid(Offset, Count, pDestValues, pType, TotalUnpackedSize))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
UINT i, j, delta = pType->NumericType.IsPackedArray ? 1 : SType::c_ScalarsPerRegister;
pSrcValues += Offset * delta;
for (i = 0, j = 0; j < Count; i += delta, ++ j)
{
// pDestValues[j] = (DEST_TYPE)pSrcValues[i];
CopyScalarValue<SourceType, DestType, SRC_TYPE, FALSE>(pSrcValues[i], &pDestValues[j], "GetScalarArray");
}
lExit:
return hr;
}
//////////////////////////////////////////////////////////////////////////
// TVariable - implements type casting and member/element retrieval
//////////////////////////////////////////////////////////////////////////
// requires that IBaseInterface contain SVariable's fields and support ID3DX11EffectVariable
template<typename IBaseInterface>
struct TVariable : public IBaseInterface
{
STDMETHOD_(BOOL, IsValid)() { return TRUE; }
STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(UINT Index)
{
SVariable *pMember;
UDataPointer dataPtr;
TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity = GetTopLevelEntity();
if (((ID3DX11Effect*)pTopLevelEntity->pEffect)->IsOptimized())
{
DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Cannot get members; effect has been Optimize()'ed");
return &g_InvalidScalarVariable;
}
if (pType->VarType != EVT_Struct)
{
DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Variable is not a structure");
return &g_InvalidScalarVariable;
}
if (!GetVariableByIndexHelper<SVariable>(Index, pType->StructType.Members, pType->StructType.pMembers,
Data.pNumeric, &pMember, &dataPtr.pGeneric))
{
return &g_InvalidScalarVariable;
}
return pTopLevelEntity->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity, pMember, dataPtr, FALSE, Index);
}
STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(LPCSTR Name)
{
SVariable *pMember;
UDataPointer dataPtr;
UINT index;
TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity = GetTopLevelEntity();
if (pTopLevelEntity->pEffect->IsOptimized())
{
DPF(0, "ID3DX11EffectVariable::GetMemberByName: Cannot get members; effect has been Optimize()'ed");
return &g_InvalidScalarVariable;
}
if (pType->VarType != EVT_Struct)
{
DPF(0, "ID3DX11EffectVariable::GetMemberByName: Variable is not a structure");
return &g_InvalidScalarVariable;
}
if (!GetVariableByNameHelper<SVariable>(Name, pType->StructType.Members, pType->StructType.pMembers,
Data.pNumeric, &pMember, &dataPtr.pGeneric, &index))
{
return &g_InvalidScalarVariable;
}
return pTopLevelEntity->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity, pMember, dataPtr, FALSE, index);
}
STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(LPCSTR Semantic)
{
SVariable *pMember;
UDataPointer dataPtr;
UINT index;
TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity = GetTopLevelEntity();
if (pTopLevelEntity->pEffect->IsOptimized())
{
DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Cannot get members; effect has been Optimize()'ed");
return &g_InvalidScalarVariable;
}
if (pType->VarType != EVT_Struct)
{
DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Variable is not a structure");
return &g_InvalidScalarVariable;
}
if (!GetVariableBySemanticHelper<SVariable>(Semantic, pType->StructType.Members, pType->StructType.pMembers,
Data.pNumeric, &pMember, &dataPtr.pGeneric, &index))
{
return &g_InvalidScalarVariable;
}
return pTopLevelEntity->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity, pMember, dataPtr, FALSE, index);
}
STDMETHOD_(ID3DX11EffectVariable*, GetElement)(UINT Index)
{
LPCSTR pFuncName = "ID3DX11EffectVariable::GetElement";
TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity = GetTopLevelEntity();
UDataPointer dataPtr;
if (pTopLevelEntity->pEffect->IsOptimized())
{
DPF(0, "ID3DX11EffectVariable::GetElement: Cannot get element; effect has been Optimize()'ed");
return &g_InvalidScalarVariable;
}
if (!IsArray())
{
DPF(0, "%s: This interface does not refer to an array", pFuncName);
return &g_InvalidScalarVariable;
}
if (Index >= pType->Elements)
{
DPF(0, "%s: Invalid element index (%d, total: %d)", pFuncName, Index, pType->Elements);
return &g_InvalidScalarVariable;
}
if (pType->BelongsInConstantBuffer())
{
dataPtr.pGeneric = Data.pNumeric + pType->Stride * Index;
}
else
{
dataPtr.pGeneric = GetBlockByIndex(pType->VarType, pType->ObjectType, Data.pGeneric, Index);
if (NULL == dataPtr.pGeneric)
{
DPF(0, "%s: Internal error", pFuncName);
return &g_InvalidScalarVariable;
}
}
return pTopLevelEntity->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity, (SVariable *) this, dataPtr, TRUE, Index);
}
STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsScalar";
if (pType->VarType != EVT_Numeric ||
pType->NumericType.NumericLayout != ENL_Scalar)
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidScalarVariable;
}
return (ID3DX11EffectScalarVariable *) this;
}
STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsVector";
if (pType->VarType != EVT_Numeric ||
pType->NumericType.NumericLayout != ENL_Vector)
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidVectorVariable;
}
return (ID3DX11EffectVectorVariable *) this;
}
STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsMatrix";
if (pType->VarType != EVT_Numeric ||
pType->NumericType.NumericLayout != ENL_Matrix)
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidMatrixVariable;
}
return (ID3DX11EffectMatrixVariable *) this;
}
STDMETHOD_(ID3DX11EffectStringVariable*, AsString)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsString";
if (!pType->IsObjectType(EOT_String))
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidStringVariable;
}
return (ID3DX11EffectStringVariable *) this;
}
STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsClassInstance";
if (!pType->IsClassInstance() )
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidClassInstanceVariable;
}
else if( pMemberData == NULL )
{
DPF(0, "%s: Non-global class instance variables (members of structs or classes) and class instances "
"inside tbuffers are not supported.", pFuncName );
return &g_InvalidClassInstanceVariable;
}
return (ID3DX11EffectClassInstanceVariable *) this;
}
STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsInterface";
if (!pType->IsInterface())
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidInterfaceVariable;
}
return (ID3DX11EffectInterfaceVariable *) this;
}
STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsShaderResource";
if (!pType->IsShaderResource())
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidShaderResourceVariable;
}
return (ID3DX11EffectShaderResourceVariable *) this;
}
STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsUnorderedAccessView";
if (!pType->IsUnorderedAccessView())
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidUnorderedAccessViewVariable;
}
return (ID3DX11EffectUnorderedAccessViewVariable *) this;
}
STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsRenderTargetView";
if (!pType->IsRenderTargetView())
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidRenderTargetViewVariable;
}
return (ID3DX11EffectRenderTargetViewVariable *) this;
}
STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencilView";
if (!pType->IsDepthStencilView())
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidDepthStencilViewVariable;
}
return (ID3DX11EffectDepthStencilViewVariable *) this;
}
STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsConstantBuffer";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidConstantBuffer;
}
STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsShader";
if (!pType->IsShader())
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidShaderVariable;
}
return (ID3DX11EffectShaderVariable *) this;
}
STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsBlend";
if (!pType->IsObjectType(EOT_Blend))
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidBlendVariable;
}
return (ID3DX11EffectBlendVariable *) this;
}
STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencil";
if (!pType->IsObjectType(EOT_DepthStencil))
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidDepthStencilVariable;
}
return (ID3DX11EffectDepthStencilVariable *) this;
}
STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsRasterizer";
if (!pType->IsObjectType(EOT_Rasterizer))
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidRasterizerVariable;
}
return (ID3DX11EffectRasterizerVariable *) this;
}
STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsSampler";
if (!pType->IsSampler())
{
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidSamplerVariable;
}
return (ID3DX11EffectSamplerVariable *) this;
}
// Numeric variables should override this
STDMETHOD(SetRawValue)(CONST void *pData, UINT Offset, UINT Count) { return ObjectSetRawValue(); }
STDMETHOD(GetRawValue)(void *pData, UINT Offset, UINT Count) { return ObjectGetRawValue(); }
};
//////////////////////////////////////////////////////////////////////////
// TTopLevelVariable - functionality for annotations and global variables
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TTopLevelVariable : public SVariable, public IBaseInterface
{
// Required to create member/element variable interfaces
CEffect *pEffect;
CEffect* GetEffect()
{
return pEffect;
}
TTopLevelVariable()
{
pEffect = NULL;
}
UINT GetTotalUnpackedSize()
{
return ((SType*)pType)->GetTotalUnpackedSize(FALSE);
}
STDMETHOD_(ID3DX11EffectType*, GetType)()
{
return (ID3DX11EffectType*)(SType*)pType;
}
TTopLevelVariable<ID3DX11EffectVariable> * GetTopLevelEntity()
{
return (TTopLevelVariable<ID3DX11EffectVariable> *)this;
}
BOOL IsArray()
{
return (pType->Elements > 0);
}
};
//////////////////////////////////////////////////////////////////////////
// TMember - functionality for structure/array members of other variables
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TMember : public SVariable, public IBaseInterface
{
// Indicates that this is a single element of a containing array
UINT IsSingleElement : 1;
// Required to create member/element variable interfaces
TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity;
TMember()
{
IsSingleElement = FALSE;
pTopLevelEntity = NULL;
}
CEffect* GetEffect()
{
return pTopLevelEntity->pEffect;
}
UINT GetTotalUnpackedSize()
{
return pType->GetTotalUnpackedSize(IsSingleElement);
}
STDMETHOD_(ID3DX11EffectType*, GetType)()
{
if (IsSingleElement)
{
return pTopLevelEntity->pEffect->CreatePooledSingleElementTypeInterface( pType );
}
else
{
return (ID3DX11EffectType*) pType;
}
}
STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
VERIFYPARAMETER(pDesc != NULL);
pDesc->Name = pName;
pDesc->Semantic = pSemantic;
pDesc->Flags = 0;
if (pTopLevelEntity->pEffect->IsReflectionData(pTopLevelEntity))
{
// Is part of an annotation
D3DXASSERT(pTopLevelEntity->pEffect->IsReflectionData(Data.pGeneric));
pDesc->Annotations = 0;
pDesc->BufferOffset = 0;
pDesc->Flags |= D3DX11_EFFECT_VARIABLE_ANNOTATION;
}
else
{
// Is part of a global variable
D3DXASSERT(pTopLevelEntity->pEffect->IsRuntimeData(pTopLevelEntity));
if (!pTopLevelEntity->pType->IsObjectType(EOT_String))
{
// strings are funny; their data is reflection data, so ignore those
D3DXASSERT(pTopLevelEntity->pEffect->IsRuntimeData(Data.pGeneric));
}
pDesc->Annotations = ((TGlobalVariable<ID3DX11Effect>*)pTopLevelEntity)->AnnotationCount;
SConstantBuffer *pCB = ((TGlobalVariable<ID3DX11Effect>*)pTopLevelEntity)->pCB;
if (pType->BelongsInConstantBuffer())
{
D3DXASSERT(pCB != NULL);
UINT_PTR offset = Data.pNumeric - pCB->pBackingStore;
D3DXASSERT(offset == (UINT)offset);
pDesc->BufferOffset = (UINT)offset;
D3DXASSERT(pDesc->BufferOffset >= 0 && pDesc->BufferOffset + GetTotalUnpackedSize() <= pCB->Size);
}
else
{
D3DXASSERT(pCB == NULL);
pDesc->BufferOffset = 0;
}
}
lExit:
return hr;
}
TTopLevelVariable<ID3DX11EffectVariable> * GetTopLevelEntity()
{
return pTopLevelEntity;
}
BOOL IsArray()
{
return (pType->Elements > 0 && !IsSingleElement);
}
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index)
{ return pTopLevelEntity->GetAnnotationByIndex(Index); }
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name)
{ return pTopLevelEntity->GetAnnotationByName(Name); }
STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)()
{ return pTopLevelEntity->GetParentConstantBuffer(); }
// Annotations should never be able to go down this codepath
void DirtyVariable()
{
// make sure to call the global variable's version of dirty variable
((TGlobalVariable<ID3DX11EffectVariable>*)pTopLevelEntity)->DirtyVariable();
}
};
//////////////////////////////////////////////////////////////////////////
// TAnnotation - functionality for top level annotations
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TAnnotation : public TVariable<TTopLevelVariable<IBaseInterface> >
{
STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
VERIFYPARAMETER(pDesc != NULL);
pDesc->Name = pName;
pDesc->Semantic = pSemantic;
pDesc->Flags = D3DX11_EFFECT_VARIABLE_ANNOTATION;
pDesc->Annotations = 0;
pDesc->BufferOffset = 0;
pDesc->ExplicitBindPoint = 0;
lExit:
return hr;
}
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index)
{
LPCSTR pFuncName = "ID3DX11EffectVariable::GetAnnotationByIndex";
DPF(0, "%s: Only variables may have annotations", pFuncName);
return &g_InvalidScalarVariable;
}
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name)
{
LPCSTR pFuncName = "ID3DX11EffectVariable::GetAnnotationByName";
DPF(0, "%s: Only variables may have annotations", pFuncName);
return &g_InvalidScalarVariable;
}
STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)()
{ return NoParentCB(); }
void DirtyVariable()
{
D3DXASSERT(0);
}
};
//////////////////////////////////////////////////////////////////////////
// TGlobalVariable - functionality for top level global variables
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TGlobalVariable : public TVariable<TTopLevelVariable<IBaseInterface> >
{
Timer LastModifiedTime;
// if numeric, pointer to the constant buffer where this variable lives
SConstantBuffer *pCB;
UINT AnnotationCount;
SAnnotation *pAnnotations;
TGlobalVariable()
{
LastModifiedTime = 0;
pCB = NULL;
AnnotationCount = 0;
pAnnotations = NULL;
}
STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
VERIFYPARAMETER(pDesc != NULL);
pDesc->Name = pName;
pDesc->Semantic = pSemantic;
pDesc->Flags = 0;
pDesc->Annotations = AnnotationCount;
if (pType->BelongsInConstantBuffer())
{
D3DXASSERT(pCB != NULL);
UINT_PTR offset = Data.pNumeric - pCB->pBackingStore;
D3DXASSERT(offset == (UINT)offset);
pDesc->BufferOffset = (UINT)offset;
D3DXASSERT(pDesc->BufferOffset >= 0 && pDesc->BufferOffset + GetTotalUnpackedSize() <= pCB->Size );
}
else
{
D3DXASSERT(pCB == NULL);
pDesc->BufferOffset = 0;
}
if (ExplicitBindPoint != -1)
{
pDesc->ExplicitBindPoint = ExplicitBindPoint;
pDesc->Flags |= D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT;
}
else
{
pDesc->ExplicitBindPoint = 0;
}
lExit:
return hr;
}
// these are all well defined for global vars
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index)
{
return GetAnnotationByIndexHelper("ID3DX11EffectVariable", Index, AnnotationCount, pAnnotations);
}
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name)
{
return GetAnnotationByNameHelper("ID3DX11EffectVariable", Name, AnnotationCount, pAnnotations);
}
STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)()
{
if (NULL != pCB)
{
D3DXASSERT(pType->BelongsInConstantBuffer());
return (ID3DX11EffectConstantBuffer*)pCB;
}
else
{
D3DXASSERT(!pType->BelongsInConstantBuffer());
return &g_InvalidConstantBuffer;
}
}
D3DX11INLINE void DirtyVariable()
{
D3DXASSERT(NULL != pCB);
pCB->IsDirty = TRUE;
LastModifiedTime = pEffect->GetCurrentTime();
}
};
//////////////////////////////////////////////////////////////////////////
// TNumericVariable - implements raw set/get functionality
//////////////////////////////////////////////////////////////////////////
// IMPORTANT NOTE: All of these numeric & object aspect classes MUST NOT
// add data members to the base variable classes. Otherwise type sizes
// will disagree between object & numeric variables and we cannot eaily
// create arrays of global variables using SGlobalVariable
// Requires that IBaseInterface have SVariable's members, GetTotalUnpackedSize() and DirtyVariable()
template<typename IBaseInterface, BOOL IsAnnotation>
struct TNumericVariable : public IBaseInterface
{
STDMETHOD(SetRawValue)(CONST void *pData, UINT ByteOffset, UINT ByteCount)
{
if (IsAnnotation)
{
return AnnotationInvalidSetCall("ID3DX11EffectVariable::SetRawValue");
}
else
{
HRESULT hr = S_OK;
#ifdef _DEBUG
LPCSTR pFuncName = "ID3DX11EffectVariable::SetRawValue";
VERIFYPARAMETER(pData);
if ((ByteOffset + ByteCount < ByteOffset) ||
(ByteCount + (BYTE*)pData < (BYTE*)pData) ||
((ByteOffset + ByteCount) > GetTotalUnpackedSize()))
{
// overflow of some kind
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
DirtyVariable();
memcpy(Data.pNumeric + ByteOffset, pData, ByteCount);
lExit:
return hr;
}
}
STDMETHOD(GetRawValue)(__out_bcount(ByteCount) void *pData, UINT ByteOffset, UINT ByteCount)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
LPCSTR pFuncName = "ID3DX11EffectVariable::GetRawValue";
VERIFYPARAMETER(pData);
if ((ByteOffset + ByteCount < ByteOffset) ||
(ByteCount + (BYTE*)pData < (BYTE*)pData) ||
((ByteOffset + ByteCount) > GetTotalUnpackedSize()))
{
// overflow of some kind
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
memcpy(pData, Data.pNumeric + ByteOffset, ByteCount);
lExit:
return hr;
}
};
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectScalarVariable (TFloatScalarVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface, BOOL IsAnnotation>
struct TFloatScalarVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
{
STDMETHOD(SetFloat)(CONST float Value);
STDMETHOD(GetFloat)(float *pValue);
STDMETHOD(SetFloatArray)(CONST float *pData, UINT Offset, UINT Count);
STDMETHOD(GetFloatArray)(float *pData, UINT Offset, UINT Count);
STDMETHOD(SetInt)(CONST int Value);
STDMETHOD(GetInt)(int *pValue);
STDMETHOD(SetIntArray)(CONST int *pData, UINT Offset, UINT Count);
STDMETHOD(GetIntArray)(int *pData, UINT Offset, UINT Count);
STDMETHOD(SetBool)(CONST BOOL Value);
STDMETHOD(GetBool)(BOOL *pValue);
STDMETHOD(SetBoolArray)(CONST BOOL *pData, UINT Offset, UINT Count);
STDMETHOD(GetBoolArray)(BOOL *pData, UINT Offset, UINT Count);
};
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloat";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return CopyScalarValue<ETVT_Float, ETVT_Float, float, FALSE>(Value, Data.pNumericFloat, pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetFloat(float *pValue)
{
return CopyScalarValue<ETVT_Float, ETVT_Float, float, TRUE>(*Data.pNumericFloat, pValue, "ID3DX11EffectScalarVariable::GetFloat");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(CONST float *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloatArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return SetScalarArray<ETVT_Float, ETVT_Float, float, float>(pData, Data.pNumericFloat, Offset, Count,
pType, GetTotalUnpackedSize(), pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, UINT Offset, UINT Count)
{
return GetScalarArray<ETVT_Float, ETVT_Float, float, float>(Data.pNumericFloat, pData, Offset, Count,
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetInt(CONST int Value)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetInt";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return CopyScalarValue<ETVT_Int, ETVT_Float, int, FALSE>(Value, Data.pNumericFloat, pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetInt(int *pValue)
{
return CopyScalarValue<ETVT_Float, ETVT_Int, float, TRUE>(*Data.pNumericFloat, pValue, "ID3DX11EffectScalarVariable::GetInt");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(CONST int *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetIntArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return SetScalarArray<ETVT_Int, ETVT_Float, int, float>(pData, Data.pNumericFloat, Offset, Count,
pType, GetTotalUnpackedSize(), pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, UINT Offset, UINT Count)
{
return GetScalarArray<ETVT_Float, ETVT_Int, float, int>(Data.pNumericFloat, pData, Offset, Count,
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetBool(CONST BOOL Value)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBool";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return CopyScalarValue<ETVT_Bool, ETVT_Float, BOOL, FALSE>(Value, Data.pNumericFloat, pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetBool(BOOL *pValue)
{
return CopyScalarValue<ETVT_Float, ETVT_Bool, float, TRUE>(*Data.pNumericFloat, pValue, "ID3DX11EffectScalarVariable::GetBool");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(CONST BOOL *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBoolArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return SetScalarArray<ETVT_Bool, ETVT_Float, BOOL, float>(pData, Data.pNumericFloat, Offset, Count,
pType, GetTotalUnpackedSize(), pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(BOOL *pData, UINT Offset, UINT Count)
{
return GetScalarArray<ETVT_Float, ETVT_Bool, float, BOOL>(Data.pNumericFloat, pData, Offset, Count,
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetBoolArray");
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectScalarVariable (TIntScalarVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface, BOOL IsAnnotation>
struct TIntScalarVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
{
STDMETHOD(SetFloat)(CONST float Value);
STDMETHOD(GetFloat)(float *pValue);
STDMETHOD(SetFloatArray)(CONST float *pData, UINT Offset, UINT Count);
STDMETHOD(GetFloatArray)(float *pData, UINT Offset, UINT Count);
STDMETHOD(SetInt)(CONST int Value);
STDMETHOD(GetInt)(int *pValue);
STDMETHOD(SetIntArray)(CONST int *pData, UINT Offset, UINT Count);
STDMETHOD(GetIntArray)(int *pData, UINT Offset, UINT Count);
STDMETHOD(SetBool)(CONST BOOL Value);
STDMETHOD(GetBool)(BOOL *pValue);
STDMETHOD(SetBoolArray)(CONST BOOL *pData, UINT Offset, UINT Count);
STDMETHOD(GetBoolArray)(BOOL *pData, UINT Offset, UINT Count);
};
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloat";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return CopyScalarValue<ETVT_Float, ETVT_Int, float, FALSE>(Value, Data.pNumericInt, pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetFloat(float *pValue)
{
return CopyScalarValue<ETVT_Int, ETVT_Float, int, TRUE>(*Data.pNumericInt, pValue, "ID3DX11EffectScalarVariable::GetFloat");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(CONST float *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloatArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return SetScalarArray<ETVT_Float, ETVT_Int, float, int>(pData, Data.pNumericInt, Offset, Count,
pType, GetTotalUnpackedSize(), pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, UINT Offset, UINT Count)
{
return GetScalarArray<ETVT_Int, ETVT_Float, int, float>(Data.pNumericInt, pData, Offset, Count,
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetInt(CONST int Value)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetInt";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return CopyScalarValue<ETVT_Int, ETVT_Int, int, FALSE>(Value, Data.pNumericInt, pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetInt(int *pValue)
{
return CopyScalarValue<ETVT_Int, ETVT_Int, int, TRUE>(*Data.pNumericInt, pValue, "ID3DX11EffectScalarVariable::GetInt");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(CONST int *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetIntArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return SetScalarArray<ETVT_Int, ETVT_Int, int, int>(pData, Data.pNumericInt, Offset, Count,
pType, GetTotalUnpackedSize(), pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, UINT Offset, UINT Count)
{
return GetScalarArray<ETVT_Int, ETVT_Int, int, int>(Data.pNumericInt, pData, Offset, Count,
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetBool(CONST BOOL Value)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBool";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return CopyScalarValue<ETVT_Bool, ETVT_Int, BOOL, FALSE>(Value, Data.pNumericInt, pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetBool(BOOL *pValue)
{
return CopyScalarValue<ETVT_Int, ETVT_Bool, int, TRUE>(*Data.pNumericInt, pValue, "ID3DX11EffectScalarVariable::GetBool");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(CONST BOOL *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBoolArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return SetScalarArray<ETVT_Bool, ETVT_Int, BOOL, int>(pData, Data.pNumericInt, Offset, Count,
pType, GetTotalUnpackedSize(), pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(BOOL *pData, UINT Offset, UINT Count)
{
return GetScalarArray<ETVT_Int, ETVT_Bool, int, BOOL>(Data.pNumericInt, pData, Offset, Count,
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetBoolArray");
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectScalarVariable (TBoolScalarVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface, BOOL IsAnnotation>
struct TBoolScalarVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
{
STDMETHOD(SetFloat)(CONST float Value);
STDMETHOD(GetFloat)(float *pValue);
STDMETHOD(SetFloatArray)(CONST float *pData, UINT Offset, UINT Count);
STDMETHOD(GetFloatArray)(float *pData, UINT Offset, UINT Count);
STDMETHOD(SetInt)(CONST int Value);
STDMETHOD(GetInt)(int *pValue);
STDMETHOD(SetIntArray)(CONST int *pData, UINT Offset, UINT Count);
STDMETHOD(GetIntArray)(int *pData, UINT Offset, UINT Count);
STDMETHOD(SetBool)(CONST BOOL Value);
STDMETHOD(GetBool)(BOOL *pValue);
STDMETHOD(SetBoolArray)(CONST BOOL *pData, UINT Offset, UINT Count);
STDMETHOD(GetBoolArray)(BOOL *pData, UINT Offset, UINT Count);
};
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloat";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return CopyScalarValue<ETVT_Float, ETVT_Bool, float, FALSE>(Value, Data.pNumericBool, pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetFloat(float *pValue)
{
return CopyScalarValue<ETVT_Bool, ETVT_Float, BOOL, TRUE>(*Data.pNumericBool, pValue, "ID3DX11EffectScalarVariable::GetFloat");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(CONST float *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloatArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return SetScalarArray<ETVT_Float, ETVT_Bool, float, BOOL>(pData, Data.pNumericBool, Offset, Count,
pType, GetTotalUnpackedSize(), pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, UINT Offset, UINT Count)
{
return GetScalarArray<ETVT_Bool, ETVT_Float, BOOL, float>(Data.pNumericBool, pData, Offset, Count,
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetInt(CONST int Value)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetInt";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return CopyScalarValue<ETVT_Int, ETVT_Bool, int, FALSE>(Value, Data.pNumericBool, pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetInt(int *pValue)
{
return CopyScalarValue<ETVT_Bool, ETVT_Int, BOOL, TRUE>(*Data.pNumericBool, pValue, "ID3DX11EffectScalarVariable::GetInt");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(CONST int *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetIntArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return SetScalarArray<ETVT_Int, ETVT_Bool, int, BOOL>(pData, Data.pNumericBool, Offset, Count,
pType, GetTotalUnpackedSize(), pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, UINT Offset, UINT Count)
{
return GetScalarArray<ETVT_Bool, ETVT_Int, BOOL, int>(Data.pNumericBool, pData, Offset, Count,
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetBool(CONST BOOL Value)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBool";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return CopyScalarValue<ETVT_Bool, ETVT_Bool, BOOL, FALSE>(Value, Data.pNumericBool, pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetBool(BOOL *pValue)
{
return CopyScalarValue<ETVT_Bool, ETVT_Bool, BOOL, TRUE>(*Data.pNumericBool, pValue, "ID3DX11EffectScalarVariable::GetBool");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(CONST BOOL *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBoolArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return SetScalarArray<ETVT_Bool, ETVT_Bool, BOOL, BOOL>(pData, Data.pNumericBool, Offset, Count,
pType, GetTotalUnpackedSize(), pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(BOOL *pData, UINT Offset, UINT Count)
{
return GetScalarArray<ETVT_Bool, ETVT_Bool, BOOL, BOOL>(Data.pNumericBool, pData, Offset, Count,
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetBoolArray");
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectVectorVariable (TVectorVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType >
struct TVectorVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
{
STDMETHOD(SetBoolVector) (CONST BOOL *pData);
STDMETHOD(SetIntVector) (CONST int *pData);
STDMETHOD(SetFloatVector)(CONST float *pData);
STDMETHOD(GetBoolVector) (BOOL *pData);
STDMETHOD(GetIntVector) (int *pData);
STDMETHOD(GetFloatVector)(float *pData);
STDMETHOD(SetBoolVectorArray) (CONST BOOL *pData, UINT Offset, UINT Count);
STDMETHOD(SetIntVectorArray) (CONST int *pData, UINT Offset, UINT Count);
STDMETHOD(SetFloatVectorArray)(CONST float *pData, UINT Offset, UINT Count);
STDMETHOD(GetBoolVectorArray) (BOOL *pData, UINT Offset, UINT Count);
STDMETHOD(GetIntVectorArray) (int *pData, UINT Offset, UINT Count);
STDMETHOD(GetFloatVectorArray)(float *pData, UINT Offset, UINT Count);
};
// Note that branches in this code is based on template parameters and will be compiled out
template <ETemplateVarType DestType, ETemplateVarType SourceType>
void __forceinline CopyDataWithTypeConversion(__out_bcount(vecCount * dstVecSize * sizeof(UINT)) void *pDest, CONST void *pSource, UINT dstVecSize, UINT srcVecSize, UINT elementCount, UINT vecCount)
{
UINT i, j;
switch (SourceType)
{
case ETVT_Bool:
switch (DestType)
{
case ETVT_Bool:
for (j=0; j<vecCount; j++)
{
dwordMemcpy(pDest, pSource, elementCount * SType::c_ScalarSize);
pDest = ((float*) pDest) + dstVecSize;
pSource = ((float*) pSource) + srcVecSize;
}
break;
case ETVT_Int:
for (j=0; j<vecCount; j++)
{
for (i=0; i<elementCount; i++)
((int*)pDest)[i] = ((BOOL*)pSource)[i] ? -1 : 0;
pDest = ((float*) pDest) + dstVecSize;
pSource = ((float*) pSource) + srcVecSize;
}
break;
case ETVT_Float:
for (j=0; j<vecCount; j++)
{
for (i=0; i<elementCount; i++)
((float*)pDest)[i] = ((BOOL*)pSource)[i] ? -1.0f : 0.0f;
pDest = ((float*) pDest) + dstVecSize;
pSource = ((float*) pSource) + srcVecSize;
}
break;
default:
D3DXASSERT(0);
}
break;
case ETVT_Int:
switch (DestType)
{
case ETVT_Bool:
for (j=0; j<vecCount; j++)
{
for (i=0; i<elementCount; i++)
((int*)pDest)[i] = (((int*)pSource)[i] != 0) ? -1 : 0;
pDest = ((float*) pDest) + dstVecSize;
pSource = ((float*) pSource) + srcVecSize;
}
break;
case ETVT_Int:
for (j=0; j<vecCount; j++)
{
dwordMemcpy(pDest, pSource, elementCount * SType::c_ScalarSize);
pDest = ((float*) pDest) + dstVecSize;
pSource = ((float*) pSource) + srcVecSize;
}
break;
case ETVT_Float:
for (j=0; j<vecCount; j++)
{
for (i=0; i<elementCount; i++)
((float*)pDest)[i] = (float)(((int*)pSource)[i]);
pDest = ((float*) pDest) + dstVecSize;
pSource = ((float*) pSource) + srcVecSize;
}
break;
default:
D3DXASSERT(0);
}
break;
case ETVT_Float:
switch (DestType)
{
case ETVT_Bool:
for (j=0; j<vecCount; j++)
{
for (i=0; i<elementCount; i++)
((int*)pDest)[i] = (((float*)pSource)[i] != 0.0f) ? -1 : 0;
pDest = ((float*) pDest) + dstVecSize;
pSource = ((float*) pSource) + srcVecSize;
}
break;
case ETVT_Int:
for (j=0; j<vecCount; j++)
{
for (i=0; i<elementCount; i++)
((int*)pDest)[i] = (int)((float*)pSource)[i];
pDest = ((float*) pDest) + dstVecSize;
pSource = ((float*) pSource) + srcVecSize;
}
break;
case ETVT_Float:
for (i=0; i<vecCount; i++)
{
dwordMemcpy( pDest, pSource, elementCount * SType::c_ScalarSize);
pDest = ((float*) pDest) + dstVecSize;
pSource = ((float*) pSource) + srcVecSize;
}
break;
default:
D3DXASSERT(0);
}
break;
default:
D3DXASSERT(0);
}
}
// Float Vector
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetFloatVector(CONST float *pData)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVector";
#ifdef _DEBUG
VERIFYPARAMETER(pData);
#endif
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
CopyDataWithTypeConversion<BaseType, ETVT_Float>(Data.pVector, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, 1);
lExit:
return hr;
}
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetFloatVector(float *pData)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVector";
#ifdef _DEBUG
VERIFYPARAMETER(pData);
#endif
CopyDataWithTypeConversion<ETVT_Float, BaseType>(pData, Data.pVector, pType->NumericType.Columns, 4, pType->NumericType.Columns, 1);
lExit:
return hr;
}
// Int Vector
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetIntVector(CONST int *pData)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetIntVector";
#ifdef _DEBUG
VERIFYPARAMETER(pData);
#endif
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
CopyDataWithTypeConversion<BaseType, ETVT_Int>(Data.pVector, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, 1);
lExit:
return hr;
}
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetIntVector(int *pData)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetIntVector";
#ifdef _DEBUG
VERIFYPARAMETER(pData);
#endif
CopyDataWithTypeConversion<ETVT_Int, BaseType>(pData, Data.pVector, pType->NumericType.Columns, 4, pType->NumericType.Columns, 1);
lExit:
return hr;
}
// Bool Vector
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetBoolVector(CONST BOOL *pData)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetBoolVector";
#ifdef _DEBUG
VERIFYPARAMETER(pData);
#endif
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
CopyDataWithTypeConversion<BaseType, ETVT_Bool>(Data.pVector, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, 1);
lExit:
return hr;
}
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetBoolVector(BOOL *pData)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetBoolVector";
#ifdef _DEBUG
VERIFYPARAMETER(pData);
#endif
CopyDataWithTypeConversion<ETVT_Bool, BaseType>(pData, Data.pVector, pType->NumericType.Columns, 4, pType->NumericType.Columns, 1);
lExit:
return hr;
}
// Vector Arrays /////////////////////////////////////////////////////////
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetFloatVectorArray(CONST float *pData, UINT Offset, UINT Count)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVectorArray";
#ifdef _DEBUG
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
// ensure we don't write over the padding at the end of the vector array
CopyDataWithTypeConversion<BaseType, ETVT_Float>(Data.pVector + Offset, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
lExit:
return hr;
}
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetFloatVectorArray(float *pData, UINT Offset, UINT Count)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVectorArray";
#ifdef _DEBUG
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
// ensure we don't read past the end of the vector array
CopyDataWithTypeConversion<ETVT_Float, BaseType>(pData, Data.pVector + Offset, pType->NumericType.Columns, 4, pType->NumericType.Columns, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
lExit:
return hr;
}
// int
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetIntVectorArray(CONST int *pData, UINT Offset, UINT Count)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetIntVectorArray";
#ifdef _DEBUG
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
// ensure we don't write over the padding at the end of the vector array
CopyDataWithTypeConversion<BaseType, ETVT_Int>(Data.pVector + Offset, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
lExit:
return hr;
}
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetIntVectorArray(int *pData, UINT Offset, UINT Count)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetIntVectorArray";
#ifdef _DEBUG
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
// ensure we don't read past the end of the vector array
CopyDataWithTypeConversion<ETVT_Int, BaseType>(pData, Data.pVector + Offset, pType->NumericType.Columns, 4, pType->NumericType.Columns, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
lExit:
return hr;
}
// bool
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetBoolVectorArray(CONST BOOL *pData, UINT Offset, UINT Count)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetBoolVectorArray";
#ifdef _DEBUG
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
// ensure we don't write over the padding at the end of the vector array
CopyDataWithTypeConversion<BaseType, ETVT_Bool>(Data.pVector + Offset, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
lExit:
return hr;
}
template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetBoolVectorArray(BOOL *pData, UINT Offset, UINT Count)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetBoolVectorArray";
#ifdef _DEBUG
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
// ensure we don't read past the end of the vector array
CopyDataWithTypeConversion<ETVT_Bool, BaseType>(pData, Data.pVector + Offset, pType->NumericType.Columns, 4, pType->NumericType.Columns, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
lExit:
return hr;
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectVector4Variable (TVectorVariable implementation) [OPTIMIZED]
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TVector4Variable : public TVectorVariable<IBaseInterface, FALSE, ETVT_Float>
{
STDMETHOD(SetFloatVector)(CONST float *pData);
STDMETHOD(GetFloatVector)(float *pData);
STDMETHOD(SetFloatVectorArray)(CONST float *pData, UINT Offset, UINT Count);
STDMETHOD(GetFloatVectorArray)(float *pData, UINT Offset, UINT Count);
};
template<typename IBaseInterface>
HRESULT TVector4Variable<IBaseInterface>::SetFloatVector(CONST float *pData)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVector";
#ifdef _DEBUG
VERIFYPARAMETER(pData);
#endif
DirtyVariable();
Data.pVector[0] = ((CEffectVector4*) pData)[0];
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TVector4Variable<IBaseInterface>::GetFloatVector(float *pData)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVector";
#ifdef _DEBUG
VERIFYPARAMETER(pData);
#endif
dwordMemcpy(pData, Data.pVector, pType->NumericType.Columns * SType::c_ScalarSize);
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TVector4Variable<IBaseInterface>::SetFloatVectorArray(CONST float *pData, UINT Offset, UINT Count)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVectorArray";
#ifdef _DEBUG
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
DirtyVariable();
// ensure we don't write over the padding at the end of the vector array
dwordMemcpy(Data.pVector + Offset, pData, min((Offset + Count) * sizeof(CEffectVector4), pType->TotalSize));
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TVector4Variable<IBaseInterface>::GetFloatVectorArray(float *pData, UINT Offset, UINT Count)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVectorArray";
#ifdef _DEBUG
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
// ensure we don't read past the end of the vector array
dwordMemcpy(pData, Data.pVector + Offset, min((Offset + Count) * sizeof(CEffectVector4), pType->TotalSize));
lExit:
return hr;
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectMatrixVariable (TMatrixVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface, BOOL IsAnnotation>
struct TMatrixVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
{
STDMETHOD(SetMatrix)(CONST float *pData);
STDMETHOD(GetMatrix)(float *pData);
STDMETHOD(SetMatrixArray)(CONST float *pData, UINT Offset, UINT Count);
STDMETHOD(GetMatrixArray)(float *pData, UINT Offset, UINT Count);
STDMETHOD(SetMatrixPointerArray)(CONST float **ppData, UINT Offset, UINT Count);
STDMETHOD(GetMatrixPointerArray)(float **ppData, UINT Offset, UINT Count);
STDMETHOD(SetMatrixTranspose)(CONST float *pData);
STDMETHOD(GetMatrixTranspose)(float *pData);
STDMETHOD(SetMatrixTransposeArray)(CONST float *pData, UINT Offset, UINT Count);
STDMETHOD(GetMatrixTransposeArray)(float *pData, UINT Offset, UINT Count);
STDMETHOD(SetMatrixTransposePointerArray)(CONST float **ppData, UINT Offset, UINT Count);
STDMETHOD(GetMatrixTransposePointerArray)(float **ppData, UINT Offset, UINT Count);
};
template<BOOL Transpose>
static void SetMatrixTransposeHelper(SType *pType, __out_bcount(64) BYTE *pDestData, CONST float* pMatrix)
{
UINT i, j;
UINT registers, entries;
if (Transpose)
{
// row major
registers = pType->NumericType.Rows;
entries = pType->NumericType.Columns;
}
else
{
// column major
registers = pType->NumericType.Columns;
entries = pType->NumericType.Rows;
}
__analysis_assume( registers <= 4 );
__analysis_assume( entries <= 4 );
for (i = 0; i < registers; ++ i)
{
for (j = 0; j < entries; ++ j)
{
#pragma prefast(suppress:__WARNING_UNRELATED_LOOP_TERMINATION, "regs / entries <= 4")
((float*)pDestData)[j] = ((float*)pMatrix)[j * 4 + i];
}
pDestData += SType::c_RegisterSize;
}
}
template<BOOL Transpose>
static void GetMatrixTransposeHelper(SType *pType, __in_bcount(64) BYTE *pSrcData, __out_ecount(16) float* pMatrix)
{
UINT i, j;
UINT registers, entries;
if (Transpose)
{
// row major
registers = pType->NumericType.Rows;
entries = pType->NumericType.Columns;
}
else
{
// column major
registers = pType->NumericType.Columns;
entries = pType->NumericType.Rows;
}
__analysis_assume( registers <= 4 );
__analysis_assume( entries <= 4 );
for (i = 0; i < registers; ++ i)
{
for (j = 0; j < entries; ++ j)
{
((float*)pMatrix)[j * 4 + i] = ((float*)pSrcData)[j];
}
pSrcData += SType::c_RegisterSize;
}
}
template<BOOL Transpose, BOOL IsSetting, BOOL ExtraIndirection>
HRESULT DoMatrixArrayInternal(SType *pType, UINT TotalUnpackedSize, BYTE *pEffectData, void *pMatrixData, UINT Offset, UINT Count, LPCSTR pFuncName)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
if (!AreBoundsValid(Offset, Count, pMatrixData, pType, TotalUnpackedSize))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
#endif
UINT i;
if ((pType->NumericType.IsColumnMajor && Transpose) || (!pType->NumericType.IsColumnMajor && !Transpose))
{
// fast path
UINT dataSize;
if (Transpose)
{
dataSize = ((pType->NumericType.Columns - 1) * 4 + pType->NumericType.Rows) * SType::c_ScalarSize;
}
else
{
dataSize = ((pType->NumericType.Rows - 1) * 4 + pType->NumericType.Columns) * SType::c_ScalarSize;
}
for (i = 0; i < Count; ++ i)
{
CEffectMatrix *pMatrix;
if (ExtraIndirection)
{
pMatrix = ((CEffectMatrix **)pMatrixData)[i];
if (!pMatrix)
{
continue;
}
}
else
{
pMatrix = ((CEffectMatrix *)pMatrixData) + i;
}
if (IsSetting)
{
dwordMemcpy(pEffectData + pType->Stride * (i + Offset), pMatrix, dataSize);
}
else
{
dwordMemcpy(pMatrix, pEffectData + pType->Stride * (i + Offset), dataSize);
}
}
}
else
{
// slow path
for (i = 0; i < Count; ++ i)
{
CEffectMatrix *pMatrix;
if (ExtraIndirection)
{
pMatrix = ((CEffectMatrix **)pMatrixData)[i];
if (!pMatrix)
{
continue;
}
}
else
{
pMatrix = ((CEffectMatrix *)pMatrixData) + i;
}
if (IsSetting)
{
SetMatrixTransposeHelper<Transpose>(pType, pEffectData + pType->Stride * (i + Offset), (float*) pMatrix);
}
else
{
GetMatrixTransposeHelper<Transpose>(pType, pEffectData + pType->Stride * (i + Offset), (float*) pMatrix);
}
}
}
lExit:
return hr;
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrix(CONST float *pData)
{
LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrix";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return DoMatrixArrayInternal<FALSE, TRUE, FALSE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, const_cast<float*>(pData), 0, 1, pFuncName);
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrix(float *pData)
{
return DoMatrixArrayInternal<FALSE, FALSE, FALSE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, pData, 0, 1, "ID3DX11EffectMatrixVariable::GetMatrix");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixArray(CONST float *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return DoMatrixArrayInternal<FALSE, TRUE, FALSE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, const_cast<float*>(pData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixArray(float *pData, UINT Offset, UINT Count)
{
return DoMatrixArrayInternal<FALSE, FALSE, FALSE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, pData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixPointerArray(CONST float **ppData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixPointerArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return DoMatrixArrayInternal<FALSE, TRUE, TRUE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, const_cast<float**>(ppData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixPointerArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixPointerArray(float **ppData, UINT Offset, UINT Count)
{
return DoMatrixArrayInternal<FALSE, FALSE, TRUE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, ppData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixPointerArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTranspose(CONST float *pData)
{
LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixTranspose";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return DoMatrixArrayInternal<TRUE, TRUE, FALSE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, const_cast<float*>(pData), 0, 1, "ID3DX11EffectMatrixVariable::SetMatrixTranspose");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTranspose(float *pData)
{
return DoMatrixArrayInternal<TRUE, FALSE, FALSE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, pData, 0, 1, "ID3DX11EffectMatrixVariable::GetMatrixTranspose");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTransposeArray(CONST float *pData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixTransposeArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return DoMatrixArrayInternal<TRUE, TRUE, FALSE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, const_cast<float*>(pData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixTransposeArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTransposeArray(float *pData, UINT Offset, UINT Count)
{
return DoMatrixArrayInternal<TRUE, FALSE, FALSE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, pData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixTransposeArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTransposePointerArray(CONST float **ppData, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixTransposePointerArray";
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
DirtyVariable();
return DoMatrixArrayInternal<TRUE, TRUE, TRUE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, const_cast<float**>(ppData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixTransposePointerArray");
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTransposePointerArray(float **ppData, UINT Offset, UINT Count)
{
return DoMatrixArrayInternal<TRUE, FALSE, TRUE>(pType, GetTotalUnpackedSize(),
Data.pNumeric, ppData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixTransposePointerArray");
}
// Optimize commonly used fast paths
// (non-annotations only!)
template<typename IBaseInterface, BOOL IsColumnMajor>
struct TMatrix4x4Variable : public TMatrixVariable<IBaseInterface, FALSE>
{
STDMETHOD(SetMatrix)(CONST float *pData);
STDMETHOD(GetMatrix)(float *pData);
STDMETHOD(SetMatrixArray)(CONST float *pData, UINT Offset, UINT Count);
STDMETHOD(GetMatrixArray)(float *pData, UINT Offset, UINT Count);
STDMETHOD(SetMatrixTranspose)(CONST float *pData);
STDMETHOD(GetMatrixTranspose)(float *pData);
STDMETHOD(SetMatrixTransposeArray)(CONST float *pData, UINT Offset, UINT Count);
STDMETHOD(GetMatrixTransposeArray)(float *pData, UINT Offset, UINT Count);
};
D3DX11INLINE static void Matrix4x4TransposeHelper(CONST void *pSrc, void *pDst)
{
BYTE *pDestData = (BYTE*)pDst;
UINT *pMatrix = (UINT*)pSrc;
((UINT*)pDestData)[0 * 4 + 0] = pMatrix[0 * 4 + 0];
((UINT*)pDestData)[0 * 4 + 1] = pMatrix[1 * 4 + 0];
((UINT*)pDestData)[0 * 4 + 2] = pMatrix[2 * 4 + 0];
((UINT*)pDestData)[0 * 4 + 3] = pMatrix[3 * 4 + 0];
((UINT*)pDestData)[1 * 4 + 0] = pMatrix[0 * 4 + 1];
((UINT*)pDestData)[1 * 4 + 1] = pMatrix[1 * 4 + 1];
((UINT*)pDestData)[1 * 4 + 2] = pMatrix[2 * 4 + 1];
((UINT*)pDestData)[1 * 4 + 3] = pMatrix[3 * 4 + 1];
((UINT*)pDestData)[2 * 4 + 0] = pMatrix[0 * 4 + 2];
((UINT*)pDestData)[2 * 4 + 1] = pMatrix[1 * 4 + 2];
((UINT*)pDestData)[2 * 4 + 2] = pMatrix[2 * 4 + 2];
((UINT*)pDestData)[2 * 4 + 3] = pMatrix[3 * 4 + 2];
((UINT*)pDestData)[3 * 4 + 0] = pMatrix[0 * 4 + 3];
((UINT*)pDestData)[3 * 4 + 1] = pMatrix[1 * 4 + 3];
((UINT*)pDestData)[3 * 4 + 2] = pMatrix[2 * 4 + 3];
((UINT*)pDestData)[3 * 4 + 3] = pMatrix[3 * 4 + 3];
}
D3DX11INLINE static void Matrix4x4Copy(CONST void *pSrc, void *pDst)
{
#if 1
// In tests, this path ended up generating faster code both on x86 and x64
// T1 - Matrix4x4Copy - this path
// T2 - Matrix4x4Transpose
// T1: 1.88 T2: 1.92 - with 32 bit copies
// T1: 1.85 T2: 1.80 - with 64 bit copies
UINT64 *pDestData = (UINT64*)pDst;
UINT64 *pMatrix = (UINT64*)pSrc;
pDestData[0 * 4 + 0] = pMatrix[0 * 4 + 0];
pDestData[0 * 4 + 1] = pMatrix[0 * 4 + 1];
pDestData[0 * 4 + 2] = pMatrix[0 * 4 + 2];
pDestData[0 * 4 + 3] = pMatrix[0 * 4 + 3];
pDestData[1 * 4 + 0] = pMatrix[1 * 4 + 0];
pDestData[1 * 4 + 1] = pMatrix[1 * 4 + 1];
pDestData[1 * 4 + 2] = pMatrix[1 * 4 + 2];
pDestData[1 * 4 + 3] = pMatrix[1 * 4 + 3];
#else
UINT *pDestData = (UINT*)pDst;
UINT *pMatrix = (UINT*)pSrc;
pDestData[0 * 4 + 0] = pMatrix[0 * 4 + 0];
pDestData[0 * 4 + 1] = pMatrix[0 * 4 + 1];
pDestData[0 * 4 + 2] = pMatrix[0 * 4 + 2];
pDestData[0 * 4 + 3] = pMatrix[0 * 4 + 3];
pDestData[1 * 4 + 0] = pMatrix[1 * 4 + 0];
pDestData[1 * 4 + 1] = pMatrix[1 * 4 + 1];
pDestData[1 * 4 + 2] = pMatrix[1 * 4 + 2];
pDestData[1 * 4 + 3] = pMatrix[1 * 4 + 3];
pDestData[2 * 4 + 0] = pMatrix[2 * 4 + 0];
pDestData[2 * 4 + 1] = pMatrix[2 * 4 + 1];
pDestData[2 * 4 + 2] = pMatrix[2 * 4 + 2];
pDestData[2 * 4 + 3] = pMatrix[2 * 4 + 3];
pDestData[3 * 4 + 0] = pMatrix[3 * 4 + 0];
pDestData[3 * 4 + 1] = pMatrix[3 * 4 + 1];
pDestData[3 * 4 + 2] = pMatrix[3 * 4 + 2];
pDestData[3 * 4 + 3] = pMatrix[3 * 4 + 3];
#endif
}
// Note that branches in this code is based on template parameters and will be compiled out
template<BOOL IsColumnMajor, BOOL Transpose, BOOL IsSetting>
D3DX11INLINE HRESULT DoMatrix4x4ArrayInternal(BYTE *pEffectData, void *pMatrixData, UINT Offset, UINT Count
#ifdef _DEBUG
, SType *pType, UINT TotalUnpackedSize, LPCSTR pFuncName)
#else
)
#endif
{
HRESULT hr = S_OK;
#ifdef _DEBUG
if (!AreBoundsValid(Offset, Count, pMatrixData, pType, TotalUnpackedSize))
{
DPF(0, "%s: Invalid range specified", pFuncName);
VH(E_INVALIDARG);
}
D3DXASSERT(pType->NumericType.IsColumnMajor == IsColumnMajor && pType->Stride == (4 * SType::c_RegisterSize));
#endif
UINT i;
if ((IsColumnMajor && Transpose) || (!IsColumnMajor && !Transpose))
{
// fast path
for (i = 0; i < Count; ++ i)
{
CEffectMatrix *pMatrix = ((CEffectMatrix *)pMatrixData) + i;
if (IsSetting)
{
Matrix4x4Copy(pMatrix, pEffectData + 4 * SType::c_RegisterSize * (i + Offset));
}
else
{
Matrix4x4Copy(pEffectData + 4 * SType::c_RegisterSize * (i + Offset), pMatrix);
}
}
}
else
{
// slow path
for (i = 0; i < Count; ++ i)
{
CEffectMatrix *pMatrix = ((CEffectMatrix *)pMatrixData) + i;
if (IsSetting)
{
Matrix4x4TransposeHelper((float*) pMatrix, pEffectData + 4 * SType::c_RegisterSize * (i + Offset));
}
else
{
Matrix4x4TransposeHelper(pEffectData + 4 * SType::c_RegisterSize * (i + Offset), (float*) pMatrix);
}
}
}
lExit:
return hr;
}
template<typename IBaseInterface, BOOL IsColumnMajor>
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrix(CONST float *pData)
{
DirtyVariable();
return DoMatrix4x4ArrayInternal<IsColumnMajor, FALSE, TRUE>(Data.pNumeric, const_cast<float*>(pData), 0, 1
#ifdef _DEBUG
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrix");
#else
);
#endif
}
template<typename IBaseInterface, BOOL IsColumnMajor>
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrix(float *pData)
{
return DoMatrix4x4ArrayInternal<IsColumnMajor, FALSE, FALSE>(Data.pNumeric, pData, 0, 1
#ifdef _DEBUG
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrix");
#else
);
#endif
}
template<typename IBaseInterface, BOOL IsColumnMajor>
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixArray(CONST float *pData, UINT Offset, UINT Count)
{
DirtyVariable();
return DoMatrix4x4ArrayInternal<IsColumnMajor, FALSE, TRUE>(Data.pNumeric, const_cast<float*>(pData), Offset, Count
#ifdef _DEBUG
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrixArray");
#else
);
#endif
}
template<typename IBaseInterface, BOOL IsColumnMajor>
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixArray(float *pData, UINT Offset, UINT Count)
{
return DoMatrix4x4ArrayInternal<IsColumnMajor, FALSE, FALSE>(Data.pNumeric, pData, Offset, Count
#ifdef _DEBUG
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrixArray");
#else
);
#endif
}
template<typename IBaseInterface, BOOL IsColumnMajor>
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixTranspose(CONST float *pData)
{
DirtyVariable();
return DoMatrix4x4ArrayInternal<IsColumnMajor, TRUE, TRUE>(Data.pNumeric, const_cast<float*>(pData), 0, 1
#ifdef _DEBUG
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrixTranspose");
#else
);
#endif
}
template<typename IBaseInterface, BOOL IsColumnMajor>
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixTranspose(float *pData)
{
return DoMatrix4x4ArrayInternal<IsColumnMajor, TRUE, FALSE>(Data.pNumeric, pData, 0, 1
#ifdef _DEBUG
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrixTranspose");
#else
);
#endif
}
template<typename IBaseInterface, BOOL IsColumnMajor>
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixTransposeArray(CONST float *pData, UINT Offset, UINT Count)
{
DirtyVariable();
return DoMatrix4x4ArrayInternal<IsColumnMajor, TRUE, TRUE>(Data.pNumeric, const_cast<float*>(pData), Offset, Count
#ifdef _DEBUG
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrixTransposeArray");
#else
);
#endif
}
template<typename IBaseInterface, BOOL IsColumnMajor>
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixTransposeArray(float *pData, UINT Offset, UINT Count)
{
return DoMatrix4x4ArrayInternal<IsColumnMajor, TRUE, FALSE>(Data.pNumeric, pData, Offset, Count
#ifdef _DEBUG
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrixTransposeArray");
#else
);
#endif
}
#ifdef _DEBUG
// Useful object macro to check bounds and parameters
#define CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, Pointer) \
HRESULT hr = S_OK; \
VERIFYPARAMETER(Pointer) \
UINT elements = IsArray() ? pType->Elements : 1; \
\
if ((Offset + Count < Offset) || (elements < Offset + Count)) \
{ \
DPF(0, "%s: Invalid range specified", pFuncName); \
VH(E_INVALIDARG); \
} \
#define CHECK_OBJECT_SCALAR_BOUNDS(Index, Pointer) \
HRESULT hr = S_OK; \
VERIFYPARAMETER(Pointer) \
UINT elements = IsArray() ? pType->Elements : 1; \
\
if (Index >= elements) \
{ \
DPF(0, "%s: Invalid index specified", pFuncName); \
VH(E_INVALIDARG); \
} \
#define CHECK_SCALAR_BOUNDS(Index) \
HRESULT hr = S_OK; \
UINT elements = IsArray() ? pType->Elements : 1; \
\
if (Index >= elements) \
{ \
DPF(0, "%s: Invalid index specified", pFuncName); \
VH(E_INVALIDARG); \
} \
#else // _DEBUG
#define CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, Pointer) \
HRESULT hr = S_OK; \
#define CHECK_OBJECT_SCALAR_BOUNDS(Index, Pointer) \
HRESULT hr = S_OK; \
#define CHECK_SCALAR_BOUNDS(Index) \
HRESULT hr = S_OK; \
#endif // _DEBUG
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectStringVariable (TStringVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface, BOOL IsAnnotation>
struct TStringVariable : public IBaseInterface
{
STDMETHOD(GetString)(LPCSTR *ppString);
STDMETHOD(GetStringArray)( __out_ecount(Count) LPCSTR *ppStrings, UINT Offset, UINT Count );
};
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TStringVariable<IBaseInterface, IsAnnotation>::GetString(LPCSTR *ppString)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectStringVariable::GetString";
VERIFYPARAMETER(ppString);
if (GetTopLevelEntity()->pEffect->IsOptimized())
{
DPF(0, "%s: Effect has been Optimize()'ed; all string/reflection data has been deleted", pFuncName);
return D3DERR_INVALIDCALL;
}
D3DXASSERT(NULL != Data.pString);
*ppString = Data.pString->pString;
lExit:
return hr;
}
template<typename IBaseInterface, BOOL IsAnnotation>
HRESULT TStringVariable<IBaseInterface, IsAnnotation>::GetStringArray( __out_ecount(Count) LPCSTR *ppStrings, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectStringVariable::GetStringArray";
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppStrings);
if (GetTopLevelEntity()->pEffect->IsOptimized())
{
DPF(0, "%s: Effect has been Optimize()'ed; all string/reflection data has been deleted", pFuncName);
return D3DERR_INVALIDCALL;
}
D3DXASSERT(NULL != Data.pString);
UINT i;
for (i = 0; i < Count; ++ i)
{
ppStrings[i] = (Data.pString + Offset + i)->pString;
}
lExit:
return hr;
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectClassInstanceVariable (TClassInstanceVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TClassInstanceVariable : public IBaseInterface
{
STDMETHOD(GetClassInstance)(ID3D11ClassInstance **ppClassInstance);
};
template<typename IBaseClassInstance>
HRESULT TClassInstanceVariable<IBaseClassInstance>::GetClassInstance(ID3D11ClassInstance** ppClassInstance)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectClassInstanceVariable::GetClassInstance";
D3DXASSERT( pMemberData != NULL );
*ppClassInstance = pMemberData->Data.pD3DClassInstance;
SAFE_ADDREF(*ppClassInstance);
lExit:
return hr;
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectInterfaceeVariable (TInterfaceVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TInterfaceVariable : public IBaseInterface
{
STDMETHOD(SetClassInstance)(ID3DX11EffectClassInstanceVariable *pEffectClassInstance);
STDMETHOD(GetClassInstance)(ID3DX11EffectClassInstanceVariable **ppEffectClassInstance);
};
template<typename IBaseInterface>
HRESULT TInterfaceVariable<IBaseInterface>::SetClassInstance(ID3DX11EffectClassInstanceVariable *pEffectClassInstance)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectInterfaceVariable::SetClassInstance";
// Note that we don't check if the types are compatible. The debug layer will complain if it is.
// IsValid() will not catch type mismatches.
SClassInstanceGlobalVariable* pCI = (SClassInstanceGlobalVariable*)pEffectClassInstance;
Data.pInterface->pClassInstance = pCI;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TInterfaceVariable<IBaseInterface>::GetClassInstance(ID3DX11EffectClassInstanceVariable **ppEffectClassInstance)
{
HRESULT hr = S_OK;
LPCSTR pFuncName = "ID3DX11EffectInterfaceVariable::GetClassInstance";
#ifdef _DEBUG
VERIFYPARAMETER(ppEffectClassInstance);
#endif
*ppEffectClassInstance = Data.pInterface->pClassInstance;
lExit:
return hr;
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectShaderResourceVariable (TShaderResourceVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TShaderResourceVariable : public IBaseInterface
{
STDMETHOD(SetResource)(ID3D11ShaderResourceView *pResource);
STDMETHOD(GetResource)(ID3D11ShaderResourceView **ppResource);
STDMETHOD(SetResourceArray)(ID3D11ShaderResourceView **ppResources, UINT Offset, UINT Count);
STDMETHOD(GetResourceArray)(ID3D11ShaderResourceView **ppResources, UINT Offset, UINT Count);
};
static LPCSTR GetTextureTypeNameFromEnum(EObjectType ObjectType)
{
switch (ObjectType)
{
case EOT_Buffer:
return "Buffer";
case EOT_Texture:
return "texture";
case EOT_Texture1D:
case EOT_Texture1DArray:
return "Texture1D";
case EOT_Texture2DMS:
case EOT_Texture2DMSArray:
return "Texture2DMS";
case EOT_Texture2D:
case EOT_Texture2DArray:
return "Texture2D";
case EOT_Texture3D:
return "Texture3D";
case EOT_TextureCube:
return "TextureCube";
case EOT_TextureCubeArray:
return "TextureCubeArray";
case EOT_RWTexture1D:
case EOT_RWTexture1DArray:
return "RWTexture1D";
case EOT_RWTexture2D:
case EOT_RWTexture2DArray:
return "RWTexture2D";
case EOT_RWTexture3D:
return "RWTexture3D";
case EOT_RWBuffer:
return "RWBuffer";
case EOT_ByteAddressBuffer:
return "ByteAddressBuffer";
case EOT_RWByteAddressBuffer:
return "RWByteAddressBuffer";
case EOT_StructuredBuffer:
return "StructuredBuffe";
case EOT_RWStructuredBuffer:
return "RWStructuredBuffer";
case EOT_RWStructuredBufferAlloc:
return "RWStructuredBufferAlloc";
case EOT_RWStructuredBufferConsume:
return "RWStructuredBufferConsume";
case EOT_AppendStructuredBuffer:
return "AppendStructuredBuffer";
case EOT_ConsumeStructuredBuffer:
return "ConsumeStructuredBuffer";
}
return "<unknown texture format>";
}
static LPCSTR GetResourceDimensionNameFromEnum(D3D11_RESOURCE_DIMENSION ResourceDimension)
{
switch (ResourceDimension)
{
case D3D11_RESOURCE_DIMENSION_BUFFER:
return "Buffer";
case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
return "Texture1D";
case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
return "Texture2D";
case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
return "Texture3D";
}
return "<unknown texture format>";
}
static LPCSTR GetSRVDimensionNameFromEnum(D3D11_SRV_DIMENSION ViewDimension)
{
switch (ViewDimension)
{
case D3D11_SRV_DIMENSION_BUFFER:
case D3D11_SRV_DIMENSION_BUFFEREX:
return "Buffer";
case D3D11_SRV_DIMENSION_TEXTURE1D:
return "Texture1D";
case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
return "Texture1DArray";
case D3D11_SRV_DIMENSION_TEXTURE2D:
return "Texture2D";
case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
return "Texture2DArray";
case D3D11_SRV_DIMENSION_TEXTURE2DMS:
return "Texture2DMS";
case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
return "Texture2DMSArray";
case D3D11_SRV_DIMENSION_TEXTURE3D:
return "Texture3D";
case D3D11_SRV_DIMENSION_TEXTURECUBE:
return "TextureCube";
}
return "<unknown texture format>";
}
static LPCSTR GetUAVDimensionNameFromEnum(D3D11_UAV_DIMENSION ViewDimension)
{
switch (ViewDimension)
{
case D3D11_UAV_DIMENSION_BUFFER:
return "Buffer";
case D3D11_UAV_DIMENSION_TEXTURE1D:
return "RWTexture1D";
case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:
return "RWTexture1DArray";
case D3D11_UAV_DIMENSION_TEXTURE2D:
return "RWTexture2D";
case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:
return "RWTexture2DArray";
case D3D11_UAV_DIMENSION_TEXTURE3D:
return "RWTexture3D";
}
return "<unknown texture format>";
}
static LPCSTR GetRTVDimensionNameFromEnum(D3D11_RTV_DIMENSION ViewDimension)
{
switch (ViewDimension)
{
case D3D11_RTV_DIMENSION_BUFFER:
return "Buffer";
case D3D11_RTV_DIMENSION_TEXTURE1D:
return "Texture1D";
case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:
return "Texture1DArray";
case D3D11_RTV_DIMENSION_TEXTURE2D:
return "Texture2D";
case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:
return "Texture2DArray";
case D3D11_RTV_DIMENSION_TEXTURE2DMS:
return "Texture2DMS";
case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:
return "Texture2DMSArray";
case D3D11_RTV_DIMENSION_TEXTURE3D:
return "Texture3D";
}
return "<unknown texture format>";
}
static LPCSTR GetDSVDimensionNameFromEnum(D3D11_DSV_DIMENSION ViewDimension)
{
switch (ViewDimension)
{
case D3D11_DSV_DIMENSION_TEXTURE1D:
return "Texture1D";
case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:
return "Texture1DArray";
case D3D11_DSV_DIMENSION_TEXTURE2D:
return "Texture2D";
case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:
return "Texture2DArray";
case D3D11_DSV_DIMENSION_TEXTURE2DMS:
return "Texture2DMS";
case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:
return "Texture2DMSArray";
}
return "<unknown texture format>";
}
static HRESULT ValidateTextureType(ID3D11ShaderResourceView *pView, EObjectType ObjectType, LPCSTR pFuncName)
{
if (NULL != pView)
{
D3D11_SHADER_RESOURCE_VIEW_DESC desc;
pView->GetDesc(&desc);
switch (ObjectType)
{
case EOT_Texture:
if (desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFER && desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFEREX)
return S_OK;
break;
case EOT_Buffer:
if (desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFER && desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFEREX)
break;
if (desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFEREX && (desc.BufferEx.Flags & D3D11_BUFFEREX_SRV_FLAG_RAW))
{
DPF(0, "%s: Resource type mismatch; %s expected, ByteAddressBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
return E_INVALIDARG;
}
else
{
ID3D11Buffer* pBuffer = NULL;
pView->GetResource( (ID3D11Resource**)&pBuffer );
D3DXASSERT( pBuffer != NULL );
D3D11_BUFFER_DESC BufDesc;
pBuffer->GetDesc( &BufDesc );
SAFE_RELEASE( pBuffer );
if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
{
DPF(0, "%s: Resource type mismatch; %s expected, StructuredBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
return E_INVALIDARG;
}
else
{
return S_OK;
}
}
break;
case EOT_Texture1D:
case EOT_Texture1DArray:
if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE1D ||
desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE1DARRAY)
return S_OK;
break;
case EOT_Texture2D:
case EOT_Texture2DArray:
if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2D ||
desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2DARRAY)
return S_OK;
break;
case EOT_Texture2DMS:
case EOT_Texture2DMSArray:
if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2DMS ||
desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY)
return S_OK;
break;
case EOT_Texture3D:
if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE3D)
return S_OK;
break;
case EOT_TextureCube:
case EOT_TextureCubeArray:
if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURECUBE ||
desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURECUBEARRAY)
return S_OK;
break;
case EOT_ByteAddressBuffer:
if (desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFEREX && (desc.BufferEx.Flags & D3D11_BUFFEREX_SRV_FLAG_RAW))
return S_OK;
break;
case EOT_StructuredBuffer:
if (desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFEREX || desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFER)
{
ID3D11Buffer* pBuffer = NULL;
pView->GetResource( (ID3D11Resource**)&pBuffer );
D3DXASSERT( pBuffer != NULL );
D3D11_BUFFER_DESC BufDesc;
pBuffer->GetDesc( &BufDesc );
SAFE_RELEASE( pBuffer );
if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
{
return S_OK;
}
else
{
DPF(0, "%s: Resource type mismatch; %s expected, non-structured Buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
return E_INVALIDARG;
}
}
break;
default:
D3DXASSERT(0); // internal error, should never get here
return E_FAIL;
}
DPF(0, "%s: Resource type mismatch; %s expected, %s provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType), GetSRVDimensionNameFromEnum(desc.ViewDimension));
return E_INVALIDARG;
}
return S_OK;
}
template<typename IBaseInterface>
HRESULT TShaderResourceVariable<IBaseInterface>::SetResource(ID3D11ShaderResourceView *pResource)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::SetResource";
VH(ValidateTextureType(pResource, pType->ObjectType, pFuncName));
#endif
// Texture variables don't need to be dirtied.
SAFE_ADDREF(pResource);
SAFE_RELEASE(Data.pShaderResource->pShaderResource);
Data.pShaderResource->pShaderResource = pResource;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderResourceVariable<IBaseInterface>::GetResource(ID3D11ShaderResourceView **ppResource)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::GetResource";
VERIFYPARAMETER(ppResource);
#endif
*ppResource = Data.pShaderResource->pShaderResource;
SAFE_ADDREF(*ppResource);
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderResourceVariable<IBaseInterface>::SetResourceArray(ID3D11ShaderResourceView **ppResources, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::SetResourceArray";
UINT i;
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
#ifdef _DEBUG
for (i = 0; i < Count; ++ i)
{
VH(ValidateTextureType(ppResources[i], pType->ObjectType, pFuncName));
}
#endif
// Texture variables don't need to be dirtied.
for (i = 0; i < Count; ++ i)
{
SShaderResource *pResourceBlock = Data.pShaderResource + Offset + i;
SAFE_ADDREF(ppResources[i]);
SAFE_RELEASE(pResourceBlock->pShaderResource);
pResourceBlock->pShaderResource = ppResources[i];
}
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderResourceVariable<IBaseInterface>::GetResourceArray(ID3D11ShaderResourceView **ppResources, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::GetResourceArray";
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
UINT i;
for (i = 0; i < Count; ++ i)
{
ppResources[i] = (Data.pShaderResource + Offset + i)->pShaderResource;
SAFE_ADDREF(ppResources[i]);
}
lExit:
return hr;
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectUnorderedAccessViewVariable (TUnorderedAccessViewVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TUnorderedAccessViewVariable : public IBaseInterface
{
STDMETHOD(SetUnorderedAccessView)(ID3D11UnorderedAccessView *pResource);
STDMETHOD(GetUnorderedAccessView)(ID3D11UnorderedAccessView **ppResource);
STDMETHOD(SetUnorderedAccessViewArray)(ID3D11UnorderedAccessView **ppResources, UINT Offset, UINT Count);
STDMETHOD(GetUnorderedAccessViewArray)(ID3D11UnorderedAccessView **ppResources, UINT Offset, UINT Count);
};
static HRESULT ValidateTextureType(ID3D11UnorderedAccessView *pView, EObjectType ObjectType, LPCSTR pFuncName)
{
if (NULL != pView)
{
D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
pView->GetDesc(&desc);
switch (ObjectType)
{
case EOT_RWBuffer:
if (desc.ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
break;
if (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_RAW)
{
DPF(0, "%s: Resource type mismatch; %s expected, RWByteAddressBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
return E_INVALIDARG;
}
else
{
ID3D11Buffer* pBuffer = NULL;
pView->GetResource( (ID3D11Resource**)&pBuffer );
D3DXASSERT( pBuffer != NULL );
D3D11_BUFFER_DESC BufDesc;
pBuffer->GetDesc( &BufDesc );
SAFE_RELEASE( pBuffer );
if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
{
DPF(0, "%s: Resource type mismatch; %s expected, an RWStructuredBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
return E_INVALIDARG;
}
else
{
return S_OK;
}
}
break;
case EOT_RWTexture1D:
case EOT_RWTexture1DArray:
if (desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE1D ||
desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE1DARRAY)
return S_OK;
break;
case EOT_RWTexture2D:
case EOT_RWTexture2DArray:
if (desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE2D ||
desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE2DARRAY)
return S_OK;
break;
case EOT_RWTexture3D:
if (desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE3D)
return S_OK;
break;
case EOT_RWByteAddressBuffer:
if (desc.ViewDimension == D3D11_UAV_DIMENSION_BUFFER && (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_RAW))
return S_OK;
break;
case EOT_RWStructuredBuffer:
if (desc.ViewDimension == D3D11_UAV_DIMENSION_BUFFER)
{
ID3D11Buffer* pBuffer = NULL;
pView->GetResource( (ID3D11Resource**)&pBuffer );
D3DXASSERT( pBuffer != NULL );
D3D11_BUFFER_DESC BufDesc;
pBuffer->GetDesc( &BufDesc );
SAFE_RELEASE( pBuffer );
if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
{
return S_OK;
}
else
{
DPF(0, "%s: Resource type mismatch; %s expected, non-structured Buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
return E_INVALIDARG;
}
}
break;
case EOT_RWStructuredBufferAlloc:
case EOT_RWStructuredBufferConsume:
if (desc.ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
break;
if (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_COUNTER)
{
return S_OK;
}
else
{
DPF(0, "%s: Resource type mismatch; %s expected, non-Counter buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
return E_INVALIDARG;
}
break;
case EOT_AppendStructuredBuffer:
case EOT_ConsumeStructuredBuffer:
if (desc.ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
break;
if (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_APPEND)
{
return S_OK;
}
else
{
DPF(0, "%s: Resource type mismatch; %s expected, non-Append buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
return E_INVALIDARG;
}
break;
default:
D3DXASSERT(0); // internal error, should never get here
return E_FAIL;
}
DPF(0, "%s: Resource type mismatch; %s expected, %s provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType), GetUAVDimensionNameFromEnum(desc.ViewDimension));
return E_INVALIDARG;
}
return S_OK;
}
template<typename IBaseInterface>
HRESULT TUnorderedAccessViewVariable<IBaseInterface>::SetUnorderedAccessView(ID3D11UnorderedAccessView *pResource)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::SetUnorderedAccessView";
VH(ValidateTextureType(pResource, pType->ObjectType, pFuncName));
#endif
// UAV variables don't need to be dirtied.
SAFE_ADDREF(pResource);
SAFE_RELEASE(Data.pUnorderedAccessView->pUnorderedAccessView);
Data.pUnorderedAccessView->pUnorderedAccessView = pResource;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TUnorderedAccessViewVariable<IBaseInterface>::GetUnorderedAccessView(ID3D11UnorderedAccessView **ppResource)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::GetUnorderedAccessView";
VERIFYPARAMETER(ppResource);
#endif
*ppResource = Data.pUnorderedAccessView->pUnorderedAccessView;
SAFE_ADDREF(*ppResource);
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TUnorderedAccessViewVariable<IBaseInterface>::SetUnorderedAccessViewArray(ID3D11UnorderedAccessView **ppResources, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::SetUnorderedAccessViewArray";
UINT i;
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
#ifdef _DEBUG
for (i = 0; i < Count; ++ i)
{
VH(ValidateTextureType(ppResources[i], pType->ObjectType, pFuncName));
}
#endif
// Texture variables don't need to be dirtied.
for (i = 0; i < Count; ++ i)
{
SUnorderedAccessView *pResourceBlock = Data.pUnorderedAccessView + Offset + i;
SAFE_ADDREF(ppResources[i]);
SAFE_RELEASE(pResourceBlock->pUnorderedAccessView);
pResourceBlock->pUnorderedAccessView = ppResources[i];
}
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TUnorderedAccessViewVariable<IBaseInterface>::GetUnorderedAccessViewArray(ID3D11UnorderedAccessView **ppResources, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::GetUnorderedAccessViewArray";
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
UINT i;
for (i = 0; i < Count; ++ i)
{
ppResources[i] = (Data.pUnorderedAccessView + Offset + i)->pUnorderedAccessView;
SAFE_ADDREF(ppResources[i]);
}
lExit:
return hr;
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectRenderTargetViewVariable (TRenderTargetViewVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TRenderTargetViewVariable : public IBaseInterface
{
STDMETHOD(SetRenderTarget)(ID3D11RenderTargetView *pResource);
STDMETHOD(GetRenderTarget)(ID3D11RenderTargetView **ppResource);
STDMETHOD(SetRenderTargetArray)(ID3D11RenderTargetView **ppResources, UINT Offset, UINT Count);
STDMETHOD(GetRenderTargetArray)(ID3D11RenderTargetView **ppResources, UINT Offset, UINT Count);
};
template<typename IBaseInterface>
HRESULT TRenderTargetViewVariable<IBaseInterface>::SetRenderTarget(ID3D11RenderTargetView *pResource)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::SetRenderTarget";
#endif
// Texture variables don't need to be dirtied.
SAFE_ADDREF(pResource);
SAFE_RELEASE(Data.pRenderTargetView->pRenderTargetView);
Data.pRenderTargetView->pRenderTargetView = pResource;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TRenderTargetViewVariable<IBaseInterface>::GetRenderTarget(ID3D11RenderTargetView **ppResource)
{
HRESULT hr = S_OK;
*ppResource = Data.pRenderTargetView->pRenderTargetView;
SAFE_ADDREF(*ppResource);
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TRenderTargetViewVariable<IBaseInterface>::SetRenderTargetArray(ID3D11RenderTargetView **ppResources, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::SetRenderTargetArray";
UINT i;
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
// Texture variables don't need to be dirtied.
for (i = 0; i < Count; ++ i)
{
SRenderTargetView *pResourceBlock = Data.pRenderTargetView + Offset + i;
SAFE_ADDREF(ppResources[i]);
SAFE_RELEASE(pResourceBlock->pRenderTargetView);
pResourceBlock->pRenderTargetView = ppResources[i];
}
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TRenderTargetViewVariable<IBaseInterface>::GetRenderTargetArray(ID3D11RenderTargetView **ppResources, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::GetRenderTargetArray";
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
UINT i;
for (i = 0; i < Count; ++ i)
{
ppResources[i] = (Data.pRenderTargetView + Offset + i)->pRenderTargetView;
SAFE_ADDREF(ppResources[i]);
}
lExit:
return hr;
}
//////////////////////////////////////////////////////////////////////////
// ID3DX11EffectDepthStencilViewVariable (TDepthStencilViewVariable implementation)
//////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TDepthStencilViewVariable : public IBaseInterface
{
STDMETHOD(SetDepthStencil)(ID3D11DepthStencilView *pResource);
STDMETHOD(GetDepthStencil)(ID3D11DepthStencilView **ppResource);
STDMETHOD(SetDepthStencilArray)(ID3D11DepthStencilView **ppResources, UINT Offset, UINT Count);
STDMETHOD(GetDepthStencilArray)(ID3D11DepthStencilView **ppResources, UINT Offset, UINT Count);
};
template<typename IBaseInterface>
HRESULT TDepthStencilViewVariable<IBaseInterface>::SetDepthStencil(ID3D11DepthStencilView *pResource)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::SetDepthStencil";
#endif
// Texture variables don't need to be dirtied.
SAFE_ADDREF(pResource);
SAFE_RELEASE(Data.pDepthStencilView->pDepthStencilView);
Data.pDepthStencilView->pDepthStencilView = pResource;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TDepthStencilViewVariable<IBaseInterface>::GetDepthStencil(ID3D11DepthStencilView **ppResource)
{
HRESULT hr = S_OK;
#ifdef _DEBUG
LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::GetDepthStencil";
VERIFYPARAMETER(ppResource);
#endif
*ppResource = Data.pDepthStencilView->pDepthStencilView;
SAFE_ADDREF(*ppResource);
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TDepthStencilViewVariable<IBaseInterface>::SetDepthStencilArray(ID3D11DepthStencilView **ppResources, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::SetDepthStencilArray";
UINT i;
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
// Texture variables don't need to be dirtied.
for (i = 0; i < Count; ++ i)
{
SDepthStencilView *pResourceBlock = Data.pDepthStencilView + Offset + i;
SAFE_ADDREF(ppResources[i]);
SAFE_RELEASE(pResourceBlock->pDepthStencilView);
pResourceBlock->pDepthStencilView = ppResources[i];
}
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TDepthStencilViewVariable<IBaseInterface>::GetDepthStencilArray(ID3D11DepthStencilView **ppResources, UINT Offset, UINT Count)
{
LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::GetDepthStencilArray";
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
UINT i;
for (i = 0; i < Count; ++ i)
{
ppResources[i] = (Data.pDepthStencilView + Offset + i)->pDepthStencilView;
SAFE_ADDREF(ppResources[i]);
}
lExit:
return hr;
}
////////////////////////////////////////////////////////////////////////////////
// ID3DX11EffectShaderVariable (TShaderVariable implementation)
////////////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TShaderVariable : public IBaseInterface
{
STDMETHOD(GetShaderDesc)(UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc);
STDMETHOD(GetVertexShader)(UINT ShaderIndex, ID3D11VertexShader **ppVS);
STDMETHOD(GetGeometryShader)(UINT ShaderIndex, ID3D11GeometryShader **ppGS);
STDMETHOD(GetPixelShader)(UINT ShaderIndex, ID3D11PixelShader **ppPS);
STDMETHOD(GetHullShader)(UINT ShaderIndex, ID3D11HullShader **ppPS);
STDMETHOD(GetDomainShader)(UINT ShaderIndex, ID3D11DomainShader **ppPS);
STDMETHOD(GetComputeShader)(UINT ShaderIndex, ID3D11ComputeShader **ppPS);
STDMETHOD(GetInputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
STDMETHOD(GetOutputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
STDMETHOD(GetPatchConstantSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
STDMETHOD_(BOOL, IsValid)();
};
template<typename IBaseInterface>
HRESULT TShaderVariable<IBaseInterface>::GetShaderDesc(UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc)
{
LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetShaderDesc";
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
Data.pShader[ShaderIndex].GetShaderDesc(pDesc, FALSE);
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderVariable<IBaseInterface>::GetVertexShader(UINT ShaderIndex, ID3D11VertexShader **ppVS)
{
LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetVertexShader";
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppVS);
VH( Data.pShader[ShaderIndex].GetVertexShader(ppVS) );
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderVariable<IBaseInterface>::GetGeometryShader(UINT ShaderIndex, ID3D11GeometryShader **ppGS)
{
LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetGeometryShader";
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppGS);
VH( Data.pShader[ShaderIndex].GetGeometryShader(ppGS) );
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderVariable<IBaseInterface>::GetPixelShader(UINT ShaderIndex, ID3D11PixelShader **ppPS)
{
LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPixelShader";
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppPS);
VH( Data.pShader[ShaderIndex].GetPixelShader(ppPS) );
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderVariable<IBaseInterface>::GetHullShader(UINT ShaderIndex, ID3D11HullShader **ppHS)
{
LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetHullShader";
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppHS);
VH( Data.pShader[ShaderIndex].GetHullShader(ppHS) );
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderVariable<IBaseInterface>::GetDomainShader(UINT ShaderIndex, ID3D11DomainShader **ppDS)
{
LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetDomainShader";
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppDS);
VH( Data.pShader[ShaderIndex].GetDomainShader(ppDS) );
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderVariable<IBaseInterface>::GetComputeShader(UINT ShaderIndex, ID3D11ComputeShader **ppCS)
{
LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetComputeShader";
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppCS);
VH( Data.pShader[ShaderIndex].GetComputeShader(ppCS) );
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderVariable<IBaseInterface>::GetInputSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
{
LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetInputSignatureElementDesc";
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
VH( Data.pShader[ShaderIndex].GetSignatureElementDesc(SShaderBlock::ST_Input, Element, pDesc) );
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderVariable<IBaseInterface>::GetOutputSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
{
LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetOutputSignatureElementDesc";
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
VH( Data.pShader[ShaderIndex].GetSignatureElementDesc(SShaderBlock::ST_Output, Element, pDesc) );
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TShaderVariable<IBaseInterface>::GetPatchConstantSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
{
LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPatchConstantSignatureElementDesc";
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
VH( Data.pShader[ShaderIndex].GetSignatureElementDesc(SShaderBlock::ST_PatchConstant, Element, pDesc) );
lExit:
return hr;
}
template<typename IBaseInterface>
BOOL TShaderVariable<IBaseInterface>::IsValid()
{
UINT numElements = IsArray()? pType->Elements : 1;
BOOL valid = TRUE;
while( numElements > 0 && ( valid = Data.pShader[ numElements-1 ].IsValid ) )
numElements--;
return valid;
}
////////////////////////////////////////////////////////////////////////////////
// ID3DX11EffectBlendVariable (TBlendVariable implementation)
////////////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TBlendVariable : public IBaseInterface
{
public:
STDMETHOD(GetBlendState)(UINT Index, ID3D11BlendState **ppBlendState);
STDMETHOD(SetBlendState)(UINT Index, ID3D11BlendState *pBlendState);
STDMETHOD(UndoSetBlendState)(UINT Index);
STDMETHOD(GetBackingStore)(UINT Index, D3D11_BLEND_DESC *pBlendDesc);
STDMETHOD_(BOOL, IsValid)();
};
template<typename IBaseInterface>
HRESULT TBlendVariable<IBaseInterface>::GetBlendState(UINT Index, ID3D11BlendState **ppBlendState)
{
LPCSTR pFuncName = "ID3DX11EffectBlendVariable::GetBlendState";
CHECK_OBJECT_SCALAR_BOUNDS(Index, ppBlendState);
*ppBlendState = Data.pBlend[Index].pBlendObject;
SAFE_ADDREF(*ppBlendState);
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TBlendVariable<IBaseInterface>::SetBlendState(UINT Index, ID3D11BlendState *pBlendState)
{
LPCSTR pFuncName = "ID3DX11EffectBlendState::SetBlendState";
CHECK_SCALAR_BOUNDS(Index);
if( !Data.pBlend[Index].IsUserManaged )
{
// Save original state object in case we UndoSet
D3DXASSERT( pMemberData[Index].Type == MDT_BlendState );
VB( pMemberData[Index].Data.pD3DEffectsManagedBlendState == NULL );
pMemberData[Index].Data.pD3DEffectsManagedBlendState = Data.pBlend[Index].pBlendObject;
Data.pBlend[Index].pBlendObject = NULL;
Data.pBlend[Index].IsUserManaged = TRUE;
}
SAFE_ADDREF( pBlendState );
SAFE_RELEASE( Data.pBlend[Index].pBlendObject );
Data.pBlend[Index].pBlendObject = pBlendState;
Data.pBlend[Index].IsValid = TRUE;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TBlendVariable<IBaseInterface>::UndoSetBlendState(UINT Index)
{
LPCSTR pFuncName = "ID3DX11EffectBlendState::UndoSetBlendState";
CHECK_SCALAR_BOUNDS(Index);
if( !Data.pBlend[Index].IsUserManaged )
{
return S_FALSE;
}
// Revert to original state object
SAFE_RELEASE( Data.pBlend[Index].pBlendObject );
Data.pBlend[Index].pBlendObject = pMemberData[Index].Data.pD3DEffectsManagedBlendState;
pMemberData[Index].Data.pD3DEffectsManagedBlendState = NULL;
Data.pBlend[Index].IsUserManaged = FALSE;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TBlendVariable<IBaseInterface>::GetBackingStore(UINT Index, D3D11_BLEND_DESC *pBlendDesc)
{
LPCSTR pFuncName = "ID3DX11EffectBlendVariable::GetBackingStore";
CHECK_OBJECT_SCALAR_BOUNDS(Index, pBlendDesc);
if( Data.pBlend[Index].IsUserManaged )
{
if( Data.pBlend[Index].pBlendObject )
{
Data.pBlend[Index].pBlendObject->GetDesc( pBlendDesc );
}
else
{
*pBlendDesc = CD3D11_BLEND_DESC( D3D11_DEFAULT );
}
}
else
{
SBlendBlock *pBlock = Data.pBlend + Index;
if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
{
pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
}
memcpy( pBlendDesc, &pBlock->BackingStore, sizeof(D3D11_BLEND_DESC) );
}
lExit:
return hr;
}
template<typename IBaseInterface>
BOOL TBlendVariable<IBaseInterface>::IsValid()
{
UINT numElements = IsArray()? pType->Elements : 1;
BOOL valid = TRUE;
while( numElements > 0 && ( valid = Data.pBlend[ numElements-1 ].IsValid ) )
numElements--;
return valid;
}
////////////////////////////////////////////////////////////////////////////////
// ID3DX11EffectDepthStencilVariable (TDepthStencilVariable implementation)
////////////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TDepthStencilVariable : public IBaseInterface
{
public:
STDMETHOD(GetDepthStencilState)(UINT Index, ID3D11DepthStencilState **ppDepthStencilState);
STDMETHOD(SetDepthStencilState)(UINT Index, ID3D11DepthStencilState *pDepthStencilState);
STDMETHOD(UndoSetDepthStencilState)(UINT Index);
STDMETHOD(GetBackingStore)(UINT Index, D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc);
STDMETHOD_(BOOL, IsValid)();
};
template<typename IBaseInterface>
HRESULT TDepthStencilVariable<IBaseInterface>::GetDepthStencilState(UINT Index, ID3D11DepthStencilState **ppDepthStencilState)
{
LPCSTR pFuncName = "ID3DX11EffectDepthStencilVariable::GetDepthStencilState";
CHECK_OBJECT_SCALAR_BOUNDS(Index, ppDepthStencilState);
*ppDepthStencilState = Data.pDepthStencil[Index].pDSObject;
SAFE_ADDREF(*ppDepthStencilState);
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TDepthStencilVariable<IBaseInterface>::SetDepthStencilState(UINT Index, ID3D11DepthStencilState *pDepthStencilState)
{
LPCSTR pFuncName = "ID3DX11EffectDepthStencilState::SetDepthStencilState";
CHECK_SCALAR_BOUNDS(Index);
if( !Data.pDepthStencil[Index].IsUserManaged )
{
// Save original state object in case we UndoSet
D3DXASSERT( pMemberData[Index].Type == MDT_DepthStencilState );
VB( pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState == NULL );
pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState = Data.pDepthStencil[Index].pDSObject;
Data.pDepthStencil[Index].pDSObject = NULL;
Data.pDepthStencil[Index].IsUserManaged = TRUE;
}
SAFE_ADDREF( pDepthStencilState );
SAFE_RELEASE( Data.pDepthStencil[Index].pDSObject );
Data.pDepthStencil[Index].pDSObject = pDepthStencilState;
Data.pDepthStencil[Index].IsValid = TRUE;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TDepthStencilVariable<IBaseInterface>::UndoSetDepthStencilState(UINT Index)
{
LPCSTR pFuncName = "ID3DX11EffectDepthStencilState::UndoSetDepthStencilState";
CHECK_SCALAR_BOUNDS(Index);
if( !Data.pDepthStencil[Index].IsUserManaged )
{
return S_FALSE;
}
// Revert to original state object
SAFE_RELEASE( Data.pDepthStencil[Index].pDSObject );
Data.pDepthStencil[Index].pDSObject = pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState;
pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState = NULL;
Data.pDepthStencil[Index].IsUserManaged = FALSE;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TDepthStencilVariable<IBaseInterface>::GetBackingStore(UINT Index, D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc)
{
LPCSTR pFuncName = "ID3DX11EffectDepthStencilVariable::GetBackingStore";
CHECK_OBJECT_SCALAR_BOUNDS(Index, pDepthStencilDesc);
if( Data.pDepthStencil[Index].IsUserManaged )
{
if( Data.pDepthStencil[Index].pDSObject )
{
Data.pDepthStencil[Index].pDSObject->GetDesc( pDepthStencilDesc );
}
else
{
*pDepthStencilDesc = CD3D11_DEPTH_STENCIL_DESC( D3D11_DEFAULT );
}
}
else
{
SDepthStencilBlock *pBlock = Data.pDepthStencil + Index;
if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
{
pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
}
memcpy(pDepthStencilDesc, &pBlock->BackingStore, sizeof(D3D11_DEPTH_STENCIL_DESC));
}
lExit:
return hr;
}
template<typename IBaseInterface>
BOOL TDepthStencilVariable<IBaseInterface>::IsValid()
{
UINT numElements = IsArray()? pType->Elements : 1;
BOOL valid = TRUE;
while( numElements > 0 && ( valid = Data.pDepthStencil[ numElements-1 ].IsValid ) )
numElements--;
return valid;
}
////////////////////////////////////////////////////////////////////////////////
// ID3DX11EffectRasterizerVariable (TRasterizerVariable implementation)
////////////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TRasterizerVariable : public IBaseInterface
{
public:
STDMETHOD(GetRasterizerState)(UINT Index, ID3D11RasterizerState **ppRasterizerState);
STDMETHOD(SetRasterizerState)(UINT Index, ID3D11RasterizerState *pRasterizerState);
STDMETHOD(UndoSetRasterizerState)(UINT Index);
STDMETHOD(GetBackingStore)(UINT Index, D3D11_RASTERIZER_DESC *pRasterizerDesc);
STDMETHOD_(BOOL, IsValid)();
};
template<typename IBaseInterface>
HRESULT TRasterizerVariable<IBaseInterface>::GetRasterizerState(UINT Index, ID3D11RasterizerState **ppRasterizerState)
{
LPCSTR pFuncName = "ID3DX11EffectRasterizerVariable::GetRasterizerState";
CHECK_OBJECT_SCALAR_BOUNDS(Index, ppRasterizerState);
*ppRasterizerState = Data.pRasterizer[Index].pRasterizerObject;
SAFE_ADDREF(*ppRasterizerState);
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TRasterizerVariable<IBaseInterface>::SetRasterizerState(UINT Index, ID3D11RasterizerState *pRasterizerState)
{
LPCSTR pFuncName = "ID3DX11EffectRasterizerState::SetRasterizerState";
CHECK_SCALAR_BOUNDS(Index);
if( !Data.pRasterizer[Index].IsUserManaged )
{
// Save original state object in case we UndoSet
D3DXASSERT( pMemberData[Index].Type == MDT_RasterizerState );
VB( pMemberData[Index].Data.pD3DEffectsManagedRasterizerState == NULL );
pMemberData[Index].Data.pD3DEffectsManagedRasterizerState = Data.pRasterizer[Index].pRasterizerObject;
Data.pRasterizer[Index].pRasterizerObject = NULL;
Data.pRasterizer[Index].IsUserManaged = TRUE;
}
SAFE_ADDREF( pRasterizerState );
SAFE_RELEASE( Data.pRasterizer[Index].pRasterizerObject );
Data.pRasterizer[Index].pRasterizerObject = pRasterizerState;
Data.pRasterizer[Index].IsValid = TRUE;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TRasterizerVariable<IBaseInterface>::UndoSetRasterizerState(UINT Index)
{
LPCSTR pFuncName = "ID3DX11EffectRasterizerState::UndoSetRasterizerState";
CHECK_SCALAR_BOUNDS(Index);
if( !Data.pRasterizer[Index].IsUserManaged )
{
return S_FALSE;
}
// Revert to original state object
SAFE_RELEASE( Data.pRasterizer[Index].pRasterizerObject );
Data.pRasterizer[Index].pRasterizerObject = pMemberData[Index].Data.pD3DEffectsManagedRasterizerState;
pMemberData[Index].Data.pD3DEffectsManagedRasterizerState = NULL;
Data.pRasterizer[Index].IsUserManaged = FALSE;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TRasterizerVariable<IBaseInterface>::GetBackingStore(UINT Index, D3D11_RASTERIZER_DESC *pRasterizerDesc)
{
LPCSTR pFuncName = "ID3DX11EffectRasterizerVariable::GetBackingStore";
CHECK_OBJECT_SCALAR_BOUNDS(Index, pRasterizerDesc);
if( Data.pRasterizer[Index].IsUserManaged )
{
if( Data.pRasterizer[Index].pRasterizerObject )
{
Data.pRasterizer[Index].pRasterizerObject->GetDesc( pRasterizerDesc );
}
else
{
*pRasterizerDesc = CD3D11_RASTERIZER_DESC( D3D11_DEFAULT );
}
}
else
{
SRasterizerBlock *pBlock = Data.pRasterizer + Index;
if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
{
pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
}
memcpy(pRasterizerDesc, &pBlock->BackingStore, sizeof(D3D11_RASTERIZER_DESC));
}
lExit:
return hr;
}
template<typename IBaseInterface>
BOOL TRasterizerVariable<IBaseInterface>::IsValid()
{
UINT numElements = IsArray()? pType->Elements : 1;
BOOL valid = TRUE;
while( numElements > 0 && ( valid = Data.pRasterizer[ numElements-1 ].IsValid ) )
numElements--;
return valid;
}
////////////////////////////////////////////////////////////////////////////////
// ID3DX11EffectSamplerVariable (TSamplerVariable implementation)
////////////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TSamplerVariable : public IBaseInterface
{
public:
STDMETHOD(GetSampler)(UINT Index, ID3D11SamplerState **ppSampler);
STDMETHOD(SetSampler)(UINT Index, ID3D11SamplerState *pSampler);
STDMETHOD(UndoSetSampler)(UINT Index);
STDMETHOD(GetBackingStore)(UINT Index, D3D11_SAMPLER_DESC *pSamplerDesc);
};
template<typename IBaseInterface>
HRESULT TSamplerVariable<IBaseInterface>::GetSampler(UINT Index, ID3D11SamplerState **ppSampler)
{
LPCSTR pFuncName = "ID3DX11EffectSamplerVariable::GetSampler";
CHECK_OBJECT_SCALAR_BOUNDS(Index, ppSampler);
*ppSampler = Data.pSampler[Index].pD3DObject;
SAFE_ADDREF(*ppSampler);
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TSamplerVariable<IBaseInterface>::SetSampler(UINT Index, ID3D11SamplerState *pSampler)
{
LPCSTR pFuncName = "ID3DX11EffectSamplerState::SetSampler";
CHECK_SCALAR_BOUNDS(Index);
// Replace all references to the old shader block with this one
GetEffect()->ReplaceSamplerReference(&Data.pSampler[Index], pSampler);
if( !Data.pSampler[Index].IsUserManaged )
{
// Save original state object in case we UndoSet
D3DXASSERT( pMemberData[Index].Type == MDT_SamplerState );
VB( pMemberData[Index].Data.pD3DEffectsManagedSamplerState == NULL );
pMemberData[Index].Data.pD3DEffectsManagedSamplerState = Data.pSampler[Index].pD3DObject;
Data.pSampler[Index].pD3DObject = NULL;
Data.pSampler[Index].IsUserManaged = TRUE;
}
SAFE_ADDREF( pSampler );
SAFE_RELEASE( Data.pSampler[Index].pD3DObject );
Data.pSampler[Index].pD3DObject = pSampler;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TSamplerVariable<IBaseInterface>::UndoSetSampler(UINT Index)
{
LPCSTR pFuncName = "ID3DX11EffectSamplerState::UndoSetSampler";
CHECK_SCALAR_BOUNDS(Index);
if( !Data.pSampler[Index].IsUserManaged )
{
return S_FALSE;
}
// Replace all references to the old shader block with this one
GetEffect()->ReplaceSamplerReference(&Data.pSampler[Index], pMemberData[Index].Data.pD3DEffectsManagedSamplerState);
// Revert to original state object
SAFE_RELEASE( Data.pSampler[Index].pD3DObject );
Data.pSampler[Index].pD3DObject = pMemberData[Index].Data.pD3DEffectsManagedSamplerState;
pMemberData[Index].Data.pD3DEffectsManagedSamplerState = NULL;
Data.pSampler[Index].IsUserManaged = FALSE;
lExit:
return hr;
}
template<typename IBaseInterface>
HRESULT TSamplerVariable<IBaseInterface>::GetBackingStore(UINT Index, D3D11_SAMPLER_DESC *pSamplerDesc)
{
LPCSTR pFuncName = "ID3DX11EffectSamplerVariable::GetBackingStore";
CHECK_OBJECT_SCALAR_BOUNDS(Index, pSamplerDesc);
if( Data.pSampler[Index].IsUserManaged )
{
if( Data.pSampler[Index].pD3DObject )
{
Data.pSampler[Index].pD3DObject->GetDesc( pSamplerDesc );
}
else
{
*pSamplerDesc = CD3D11_SAMPLER_DESC( D3D11_DEFAULT );
}
}
else
{
SSamplerBlock *pBlock = Data.pSampler + Index;
if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
{
pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
}
memcpy(pSamplerDesc, &pBlock->BackingStore.SamplerDesc, sizeof(D3D11_SAMPLER_DESC));
}
lExit:
return hr;
}
////////////////////////////////////////////////////////////////////////////////
// TUncastableVariable
////////////////////////////////////////////////////////////////////////////////
template<typename IBaseInterface>
struct TUncastableVariable : public IBaseInterface
{
STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)();
STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)();
STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)();
STDMETHOD_(ID3DX11EffectStringVariable*, AsString)();
STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)();
STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)();
STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)();
STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)();
STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)();
STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)();
STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)();
STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)();
STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)();
STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)();
STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)();
STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)();
};
template<typename IBaseInterface>
ID3DX11EffectScalarVariable * TUncastableVariable<IBaseInterface>::AsScalar()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsScalar";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidScalarVariable;
}
template<typename IBaseInterface>
ID3DX11EffectVectorVariable * TUncastableVariable<IBaseInterface>::AsVector()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsVector";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidVectorVariable;
}
template<typename IBaseInterface>
ID3DX11EffectMatrixVariable * TUncastableVariable<IBaseInterface>::AsMatrix()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsMatrix";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidMatrixVariable;
}
template<typename IBaseInterface>
ID3DX11EffectStringVariable * TUncastableVariable<IBaseInterface>::AsString()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsString";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidStringVariable;
}
template<typename IBaseClassInstance>
ID3DX11EffectClassInstanceVariable * TUncastableVariable<IBaseClassInstance>::AsClassInstance()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsClassInstance";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidClassInstanceVariable;
}
template<typename IBaseInterface>
ID3DX11EffectInterfaceVariable * TUncastableVariable<IBaseInterface>::AsInterface()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsInterface";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidInterfaceVariable;
}
template<typename IBaseInterface>
ID3DX11EffectShaderResourceVariable * TUncastableVariable<IBaseInterface>::AsShaderResource()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsShaderResource";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidShaderResourceVariable;
}
template<typename IBaseInterface>
ID3DX11EffectUnorderedAccessViewVariable * TUncastableVariable<IBaseInterface>::AsUnorderedAccessView()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsUnorderedAccessView";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidUnorderedAccessViewVariable;
}
template<typename IBaseInterface>
ID3DX11EffectRenderTargetViewVariable * TUncastableVariable<IBaseInterface>::AsRenderTargetView()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsRenderTargetView";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidRenderTargetViewVariable;
}
template<typename IBaseInterface>
ID3DX11EffectDepthStencilViewVariable * TUncastableVariable<IBaseInterface>::AsDepthStencilView()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencilView";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidDepthStencilViewVariable;
}
template<typename IBaseInterface>
ID3DX11EffectConstantBuffer * TUncastableVariable<IBaseInterface>::AsConstantBuffer()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsConstantBuffer";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidConstantBuffer;
}
template<typename IBaseInterface>
ID3DX11EffectShaderVariable * TUncastableVariable<IBaseInterface>::AsShader()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsShader";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidShaderVariable;
}
template<typename IBaseInterface>
ID3DX11EffectBlendVariable * TUncastableVariable<IBaseInterface>::AsBlend()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsBlend";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidBlendVariable;
}
template<typename IBaseInterface>
ID3DX11EffectDepthStencilVariable * TUncastableVariable<IBaseInterface>::AsDepthStencil()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencil";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidDepthStencilVariable;
}
template<typename IBaseInterface>
ID3DX11EffectRasterizerVariable * TUncastableVariable<IBaseInterface>::AsRasterizer()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsRasterizer";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidRasterizerVariable;
}
template<typename IBaseInterface>
ID3DX11EffectSamplerVariable * TUncastableVariable<IBaseInterface>::AsSampler()
{
LPCSTR pFuncName = "ID3DX11EffectVariable::AsSampler";
DPF(0, "%s: Invalid typecast", pFuncName);
return &g_InvalidSamplerVariable;
}
////////////////////////////////////////////////////////////////////////////////
// Macros to instantiate the myriad templates
////////////////////////////////////////////////////////////////////////////////
// generates a global variable, annotation, global variable member, and annotation member of each struct type
#define GenerateReflectionClasses(Type, BaseInterface) \
struct S##Type##GlobalVariable : public T##Type##Variable<TGlobalVariable<BaseInterface>, FALSE> { }; \
struct S##Type##Annotation : public T##Type##Variable<TAnnotation<BaseInterface>, TRUE> { }; \
struct S##Type##GlobalVariableMember : public T##Type##Variable<TVariable<TMember<BaseInterface> >, FALSE> { }; \
struct S##Type##AnnotationMember : public T##Type##Variable<TVariable<TMember<BaseInterface> >, TRUE> { };
#define GenerateVectorReflectionClasses(Type, BaseType, BaseInterface) \
struct S##Type##GlobalVariable : public TVectorVariable<TGlobalVariable<BaseInterface>, FALSE, BaseType> { }; \
struct S##Type##Annotation : public TVectorVariable<TAnnotation<BaseInterface>, TRUE, BaseType> { }; \
struct S##Type##GlobalVariableMember : public TVectorVariable<TVariable<TMember<BaseInterface> >, FALSE, BaseType> { }; \
struct S##Type##AnnotationMember : public TVectorVariable<TVariable<TMember<BaseInterface> >, TRUE, BaseType> { };
#define GenerateReflectionGlobalOnlyClasses(Type) \
struct S##Type##GlobalVariable : public T##Type##Variable<TGlobalVariable<ID3DX11Effect##Type##Variable> > { }; \
struct S##Type##GlobalVariableMember : public T##Type##Variable<TVariable<TMember<ID3DX11Effect##Type##Variable> > > { }; \
GenerateReflectionClasses(Numeric, ID3DX11EffectVariable);
GenerateReflectionClasses(FloatScalar, ID3DX11EffectScalarVariable);
GenerateReflectionClasses(IntScalar, ID3DX11EffectScalarVariable);
GenerateReflectionClasses(BoolScalar, ID3DX11EffectScalarVariable);
GenerateVectorReflectionClasses(FloatVector, ETVT_Float, ID3DX11EffectVectorVariable);
GenerateVectorReflectionClasses(BoolVector, ETVT_Bool, ID3DX11EffectVectorVariable);
GenerateVectorReflectionClasses(IntVector, ETVT_Int, ID3DX11EffectVectorVariable);
GenerateReflectionClasses(Matrix, ID3DX11EffectMatrixVariable);
GenerateReflectionClasses(String, ID3DX11EffectStringVariable);
GenerateReflectionGlobalOnlyClasses(ClassInstance);
GenerateReflectionGlobalOnlyClasses(Interface);
GenerateReflectionGlobalOnlyClasses(ShaderResource);
GenerateReflectionGlobalOnlyClasses(UnorderedAccessView);
GenerateReflectionGlobalOnlyClasses(RenderTargetView);
GenerateReflectionGlobalOnlyClasses(DepthStencilView);
GenerateReflectionGlobalOnlyClasses(Shader);
GenerateReflectionGlobalOnlyClasses(Blend);
GenerateReflectionGlobalOnlyClasses(DepthStencil);
GenerateReflectionGlobalOnlyClasses(Rasterizer);
GenerateReflectionGlobalOnlyClasses(Sampler);
// Optimized matrix classes
struct SMatrix4x4ColumnMajorGlobalVariable : public TMatrix4x4Variable<TGlobalVariable<ID3DX11EffectMatrixVariable>, TRUE> { };
struct SMatrix4x4RowMajorGlobalVariable : public TMatrix4x4Variable<TGlobalVariable<ID3DX11EffectMatrixVariable>, FALSE> { };
struct SMatrix4x4ColumnMajorGlobalVariableMember : public TMatrix4x4Variable<TVariable<TMember<ID3DX11EffectMatrixVariable> >, TRUE> { };
struct SMatrix4x4RowMajorGlobalVariableMember : public TMatrix4x4Variable<TVariable<TMember<ID3DX11EffectMatrixVariable> >, FALSE> { };
// Optimized vector classes
struct SFloatVector4GlobalVariable : public TVector4Variable<TGlobalVariable<ID3DX11EffectVectorVariable> > { };
struct SFloatVector4GlobalVariableMember : public TVector4Variable<TVariable<TMember<ID3DX11EffectVectorVariable> > > { };
// These 3 classes should never be used directly
// The "base" global variable struct (all global variables should be the same size in bytes,
// but we pick this as the default).
struct SGlobalVariable : public TGlobalVariable<ID3DX11EffectVariable>
{
};
// The "base" annotation struct (all annotations should be the same size in bytes,
// but we pick this as the default).
struct SAnnotation : public TAnnotation<ID3DX11EffectVariable>
{
};
// The "base" variable member struct (all annotation/global variable members should be the
// same size in bytes, but we pick this as the default).
struct SMember : public TVariable<TMember<ID3DX11EffectVariable> >
{
};
// creates a new variable of the appropriate polymorphic type where pVar was
HRESULT PlacementNewVariable(void *pVar, SType *pType, BOOL IsAnnotation);
SMember * CreateNewMember(SType *pType, BOOL IsAnnotation);
| 35.825792 | 203 | 0.685259 | gscept |
29c56c3d1bcb1787513d3c3dae76cd1ad43545c3 | 38,414 | cpp | C++ | Source/Engine/Graphics/Batch.cpp | vivienneanthony/Existence | 8eaed7901279fd73f444c30795e7954ad70d0091 | [
"Apache-2.0"
] | 7 | 2015-01-22T05:24:44.000Z | 2019-06-13T16:16:13.000Z | Source/Engine/Graphics/Batch.cpp | vivienneanthony/Existence | 8eaed7901279fd73f444c30795e7954ad70d0091 | [
"Apache-2.0"
] | null | null | null | Source/Engine/Graphics/Batch.cpp | vivienneanthony/Existence | 8eaed7901279fd73f444c30795e7954ad70d0091 | [
"Apache-2.0"
] | null | null | null | //
// Copyright (c) 2008-2014 the Urho3D project.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
#include "Precompiled.h"
#include "Camera.h"
#include "Geometry.h"
#include "Graphics.h"
#include "GraphicsImpl.h"
#include "Material.h"
#include "Node.h"
#include "Renderer.h"
#include "Profiler.h"
#include "Scene.h"
#include "ShaderVariation.h"
#include "Sort.h"
#include "Technique.h"
#include "Texture2D.h"
#include "VertexBuffer.h"
#include "View.h"
#include "Zone.h"
#include "DebugNew.h"
namespace Urho3D
{
inline bool CompareBatchesState(Batch* lhs, Batch* rhs)
{
if (lhs->sortKey_ != rhs->sortKey_)
return lhs->sortKey_ < rhs->sortKey_;
else
return lhs->distance_ < rhs->distance_;
}
inline bool CompareBatchesFrontToBack(Batch* lhs, Batch* rhs)
{
if (lhs->distance_ != rhs->distance_)
return lhs->distance_ < rhs->distance_;
else
return lhs->sortKey_ < rhs->sortKey_;
}
inline bool CompareBatchesBackToFront(Batch* lhs, Batch* rhs)
{
if (lhs->distance_ != rhs->distance_)
return lhs->distance_ > rhs->distance_;
else
return lhs->sortKey_ < rhs->sortKey_;
}
inline bool CompareInstancesFrontToBack(const InstanceData& lhs, const InstanceData& rhs)
{
return lhs.distance_ < rhs.distance_;
}
void CalculateShadowMatrix(Matrix4& dest, LightBatchQueue* queue, unsigned split, Renderer* renderer, const Vector3& translation)
{
Camera* shadowCamera = queue->shadowSplits_[split].shadowCamera_;
const IntRect& viewport = queue->shadowSplits_[split].shadowViewport_;
Matrix3x4 posAdjust(translation, Quaternion::IDENTITY, 1.0f);
Matrix3x4 shadowView(shadowCamera->GetView());
Matrix4 shadowProj(shadowCamera->GetProjection());
Matrix4 texAdjust(Matrix4::IDENTITY);
Texture2D* shadowMap = queue->shadowMap_;
if (!shadowMap)
return;
float width = (float)shadowMap->GetWidth();
float height = (float)shadowMap->GetHeight();
Vector2 offset(
(float)viewport.left_ / width,
(float)viewport.top_ / height
);
Vector2 scale(
0.5f * (float)viewport.Width() / width,
0.5f * (float)viewport.Height() / height
);
#ifdef URHO3D_OPENGL
offset.x_ += scale.x_;
offset.y_ += scale.y_;
offset.y_ = 1.0f - offset.y_;
// If using 4 shadow samples, offset the position diagonally by half pixel
if (renderer->GetShadowQuality() & SHADOWQUALITY_HIGH_16BIT)
{
offset.x_ -= 0.5f / width;
offset.y_ -= 0.5f / height;
}
texAdjust.SetTranslation(Vector3(offset.x_, offset.y_, 0.5f));
texAdjust.SetScale(Vector3(scale.x_, scale.y_, 0.5f));
#else
offset.x_ += scale.x_ + 0.5f / width;
offset.y_ += scale.y_ + 0.5f / height;
if (renderer->GetShadowQuality() & SHADOWQUALITY_HIGH_16BIT)
{
offset.x_ -= 0.5f / width;
offset.y_ -= 0.5f / height;
}
scale.y_ = -scale.y_;
texAdjust.SetTranslation(Vector3(offset.x_, offset.y_, 0.0f));
texAdjust.SetScale(Vector3(scale.x_, scale.y_, 1.0f));
#endif
dest = texAdjust * shadowProj * shadowView * posAdjust;
}
void CalculateSpotMatrix(Matrix4& dest, Light* light, const Vector3& translation)
{
Node* lightNode = light->GetNode();
Matrix3x4 posAdjust(translation, Quaternion::IDENTITY, 1.0f);
Matrix3x4 spotView = Matrix3x4(lightNode->GetWorldPosition(), lightNode->GetWorldRotation(), 1.0f).Inverse();
Matrix4 spotProj(Matrix4::ZERO);
Matrix4 texAdjust(Matrix4::IDENTITY);
// Make the projected light slightly smaller than the shadow map to prevent light spill
float h = 1.005f / tanf(light->GetFov() * M_DEGTORAD * 0.5f);
float w = h / light->GetAspectRatio();
spotProj.m00_ = w;
spotProj.m11_ = h;
spotProj.m22_ = 1.0f / Max(light->GetRange(), M_EPSILON);
spotProj.m32_ = 1.0f;
#ifdef URHO3D_OPENGL
texAdjust.SetTranslation(Vector3(0.5f, 0.5f, 0.5f));
texAdjust.SetScale(Vector3(0.5f, -0.5f, 0.5f));
#else
texAdjust.SetTranslation(Vector3(0.5f, 0.5f, 0.0f));
texAdjust.SetScale(Vector3(0.5f, -0.5f, 1.0f));
#endif
dest = texAdjust * spotProj * spotView * posAdjust;
}
void Batch::CalculateSortKey()
{
unsigned shaderID = ((*((unsigned*)&vertexShader_) / sizeof(ShaderVariation)) + (*((unsigned*)&pixelShader_) / sizeof(ShaderVariation))) & 0x3fff;
if (!isBase_)
shaderID |= 0x8000;
if (pass_ && pass_->GetAlphaMask())
shaderID |= 0x4000;
unsigned lightQueueID = (*((unsigned*)&lightQueue_) / sizeof(LightBatchQueue)) & 0xffff;
unsigned materialID = (*((unsigned*)&material_) / sizeof(Material)) & 0xffff;
unsigned geometryID = (*((unsigned*)&geometry_) / sizeof(Geometry)) & 0xffff;
sortKey_ = (((unsigned long long)shaderID) << 48) | (((unsigned long long)lightQueueID) << 32) |
(((unsigned long long)materialID) << 16) | geometryID;
}
void Batch::Prepare(View* view, bool setModelTransform) const
{
if (!vertexShader_ || !pixelShader_)
return;
Graphics* graphics = view->GetGraphics();
Renderer* renderer = view->GetRenderer();
Node* cameraNode = camera_ ? camera_->GetNode() : 0;
Light* light = lightQueue_ ? lightQueue_->light_ : 0;
Texture2D* shadowMap = lightQueue_ ? lightQueue_->shadowMap_ : 0;
// Set pass / material-specific renderstates
if (pass_ && material_)
{
bool isShadowPass = pass_->GetType() == PASS_SHADOW;
BlendMode blend = pass_->GetBlendMode();
// Turn additive blending into subtract if the light is negative
if (light && light->IsNegative())
{
if (blend == BLEND_ADD)
blend = BLEND_SUBTRACT;
else if (blend == BLEND_ADDALPHA)
blend = BLEND_SUBTRACTALPHA;
}
graphics->SetBlendMode(blend);
renderer->SetCullMode(isShadowPass ? material_->GetShadowCullMode() : material_->GetCullMode(), camera_);
if (!isShadowPass)
{
const BiasParameters& depthBias = material_->GetDepthBias();
graphics->SetDepthBias(depthBias.constantBias_, depthBias.slopeScaledBias_);
}
graphics->SetDepthTest(pass_->GetDepthTestMode());
graphics->SetDepthWrite(pass_->GetDepthWrite());
}
// Set shaders first. The available shader parameters and their register/uniform positions depend on the currently set shaders
graphics->SetShaders(vertexShader_, pixelShader_);
// Set global (per-frame) shader parameters
if (graphics->NeedParameterUpdate(SP_FRAME, (void*)0))
view->SetGlobalShaderParameters();
// Set camera shader parameters
unsigned cameraHash = overrideView_ ? (unsigned)(size_t)camera_ + 4 : (unsigned)(size_t)camera_;
if (graphics->NeedParameterUpdate(SP_CAMERA, reinterpret_cast<void*>(cameraHash)))
view->SetCameraShaderParameters(camera_, true, overrideView_);
// Set viewport shader parameters
IntRect viewport = graphics->GetViewport();
IntVector2 viewSize = IntVector2(viewport.Width(), viewport.Height());
unsigned viewportHash = viewSize.x_ | (viewSize.y_ << 16);
if (graphics->NeedParameterUpdate(SP_VIEWPORT, reinterpret_cast<void*>(viewportHash)))
{
// During renderpath commands the G-Buffer or viewport texture is assumed to always be viewport-sized
view->SetGBufferShaderParameters(viewSize, IntRect(0, 0, viewSize.x_, viewSize.y_));
}
// Set model or skinning transforms
if (setModelTransform && graphics->NeedParameterUpdate(SP_OBJECTTRANSFORM, worldTransform_))
{
if (geometryType_ == GEOM_SKINNED)
{
graphics->SetShaderParameter(VSP_SKINMATRICES, reinterpret_cast<const float*>(worldTransform_),
12 * numWorldTransforms_);
}
else
graphics->SetShaderParameter(VSP_MODEL, *worldTransform_);
// Set the orientation for billboards, either from the object itself or from the camera
if (geometryType_ == GEOM_BILLBOARD)
{
if (numWorldTransforms_ > 1)
graphics->SetShaderParameter(VSP_BILLBOARDROT, worldTransform_[1].RotationMatrix());
else
graphics->SetShaderParameter(VSP_BILLBOARDROT, cameraNode->GetWorldRotation().RotationMatrix());
}
}
// Set zone-related shader parameters
BlendMode blend = graphics->GetBlendMode();
// If the pass is additive, override fog color to black so that shaders do not need a separate additive path
bool overrideFogColorToBlack = blend == BLEND_ADD || blend == BLEND_ADDALPHA;
unsigned zoneHash = (unsigned)(size_t)zone_;
if (overrideFogColorToBlack)
zoneHash += 0x80000000;
if (zone_ && graphics->NeedParameterUpdate(SP_ZONE, reinterpret_cast<void*>(zoneHash)))
{
graphics->SetShaderParameter(VSP_AMBIENTSTARTCOLOR, zone_->GetAmbientStartColor());
graphics->SetShaderParameter(VSP_AMBIENTENDCOLOR, zone_->GetAmbientEndColor().ToVector4() - zone_->GetAmbientStartColor().ToVector4());
const BoundingBox& box = zone_->GetBoundingBox();
Vector3 boxSize = box.Size();
Matrix3x4 adjust(Matrix3x4::IDENTITY);
adjust.SetScale(Vector3(1.0f / boxSize.x_, 1.0f / boxSize.y_, 1.0f / boxSize.z_));
adjust.SetTranslation(Vector3(0.5f, 0.5f, 0.5f));
Matrix3x4 zoneTransform = adjust * zone_->GetInverseWorldTransform();
graphics->SetShaderParameter(VSP_ZONE, zoneTransform);
graphics->SetShaderParameter(PSP_AMBIENTCOLOR, zone_->GetAmbientColor());
graphics->SetShaderParameter(PSP_FOGCOLOR, overrideFogColorToBlack ? Color::BLACK : zone_->GetFogColor());
float farClip = camera_->GetFarClip();
float fogStart = Min(zone_->GetFogStart(), farClip);
float fogEnd = Min(zone_->GetFogEnd(), farClip);
if (fogStart >= fogEnd * (1.0f - M_LARGE_EPSILON))
fogStart = fogEnd * (1.0f - M_LARGE_EPSILON);
float fogRange = Max(fogEnd - fogStart, M_EPSILON);
Vector4 fogParams(fogEnd / farClip, farClip / fogRange, 0.0f, 0.0f);
Node* zoneNode = zone_->GetNode();
if (zone_->GetHeightFog() && zoneNode)
{
Vector3 worldFogHeightVec = zoneNode->GetWorldTransform() * Vector3(0.0f, zone_->GetFogHeight(), 0.0f);
fogParams.z_ = worldFogHeightVec.y_;
fogParams.w_ = zone_->GetFogHeightScale() / Max(zoneNode->GetWorldScale().y_, M_EPSILON);
}
graphics->SetShaderParameter(PSP_FOGPARAMS, fogParams);
}
// Set light-related shader parameters
if (lightQueue_)
{
if (graphics->NeedParameterUpdate(SP_VERTEXLIGHTS, lightQueue_) && graphics->HasShaderParameter(VS, VSP_VERTEXLIGHTS))
{
Vector4 vertexLights[MAX_VERTEX_LIGHTS * 3];
const PODVector<Light*>& lights = lightQueue_->vertexLights_;
for (unsigned i = 0; i < lights.Size(); ++i)
{
Light* vertexLight = lights[i];
Node* vertexLightNode = vertexLight->GetNode();
LightType type = vertexLight->GetLightType();
// Attenuation
float invRange, cutoff, invCutoff;
if (type == LIGHT_DIRECTIONAL)
invRange = 0.0f;
else
invRange = 1.0f / Max(vertexLight->GetRange(), M_EPSILON);
if (type == LIGHT_SPOT)
{
cutoff = Cos(vertexLight->GetFov() * 0.5f);
invCutoff = 1.0f / (1.0f - cutoff);
}
else
{
cutoff = -1.0f;
invCutoff = 1.0f;
}
// Color
float fade = 1.0f;
float fadeEnd = vertexLight->GetDrawDistance();
float fadeStart = vertexLight->GetFadeDistance();
// Do fade calculation for light if both fade & draw distance defined
if (vertexLight->GetLightType() != LIGHT_DIRECTIONAL && fadeEnd > 0.0f && fadeStart > 0.0f && fadeStart < fadeEnd)
fade = Min(1.0f - (vertexLight->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 1.0f);
Color color = vertexLight->GetEffectiveColor() * fade;
vertexLights[i * 3] = Vector4(color.r_, color.g_, color.b_, invRange);
// Direction
vertexLights[i * 3 + 1] = Vector4(-(vertexLightNode->GetWorldDirection()), cutoff);
// Position
vertexLights[i * 3 + 2] = Vector4(vertexLightNode->GetWorldPosition(), invCutoff);
}
if (lights.Size())
graphics->SetShaderParameter(VSP_VERTEXLIGHTS, vertexLights[0].Data(), lights.Size() * 3 * 4);
}
}
if (light && graphics->NeedParameterUpdate(SP_LIGHT, light))
{
// Deferred light volume batches operate in a camera-centered space. Detect from material, zone & pass all being null
bool isLightVolume = !material_ && !pass_ && !zone_;
Matrix3x4 cameraEffectiveTransform = camera_->GetEffectiveWorldTransform();
Vector3 cameraEffectivePos = cameraEffectiveTransform.Translation();
Node* lightNode = light->GetNode();
Matrix3 lightWorldRotation = lightNode->GetWorldRotation().RotationMatrix();
graphics->SetShaderParameter(VSP_LIGHTDIR, lightWorldRotation * Vector3::BACK);
float atten = 1.0f / Max(light->GetRange(), M_EPSILON);
graphics->SetShaderParameter(VSP_LIGHTPOS, Vector4(lightNode->GetWorldPosition(), atten));
if (graphics->HasShaderParameter(VS, VSP_LIGHTMATRICES))
{
switch (light->GetLightType())
{
case LIGHT_DIRECTIONAL:
{
Matrix4 shadowMatrices[MAX_CASCADE_SPLITS];
unsigned numSplits = lightQueue_->shadowSplits_.Size();
for (unsigned i = 0; i < numSplits; ++i)
CalculateShadowMatrix(shadowMatrices[i], lightQueue_, i, renderer, Vector3::ZERO);
graphics->SetShaderParameter(VSP_LIGHTMATRICES, shadowMatrices[0].Data(), 16 * numSplits);
}
break;
case LIGHT_SPOT:
{
Matrix4 shadowMatrices[2];
CalculateSpotMatrix(shadowMatrices[0], light, Vector3::ZERO);
bool isShadowed = shadowMap && graphics->HasTextureUnit(TU_SHADOWMAP);
if (isShadowed)
CalculateShadowMatrix(shadowMatrices[1], lightQueue_, 0, renderer, Vector3::ZERO);
graphics->SetShaderParameter(VSP_LIGHTMATRICES, shadowMatrices[0].Data(), isShadowed ? 32 : 16);
}
break;
case LIGHT_POINT:
{
Matrix4 lightVecRot(lightNode->GetWorldRotation().RotationMatrix());
// HLSL compiler will pack the parameters as if the matrix is only 3x4, so must be careful to not overwrite
// the next parameter
#ifdef URHO3D_OPENGL
graphics->SetShaderParameter(VSP_LIGHTMATRICES, lightVecRot.Data(), 16);
#else
graphics->SetShaderParameter(VSP_LIGHTMATRICES, lightVecRot.Data(), 12);
#endif
}
break;
}
}
float fade = 1.0f;
float fadeEnd = light->GetDrawDistance();
float fadeStart = light->GetFadeDistance();
// Do fade calculation for light if both fade & draw distance defined
if (light->GetLightType() != LIGHT_DIRECTIONAL && fadeEnd > 0.0f && fadeStart > 0.0f && fadeStart < fadeEnd)
fade = Min(1.0f - (light->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 1.0f);
// Negative lights will use subtract blending, so write absolute RGB values to the shader parameter
graphics->SetShaderParameter(PSP_LIGHTCOLOR, Color(light->GetEffectiveColor().Abs(),
light->GetEffectiveSpecularIntensity()) * fade);
graphics->SetShaderParameter(PSP_LIGHTDIR, lightWorldRotation * Vector3::BACK);
graphics->SetShaderParameter(PSP_LIGHTPOS, Vector4((isLightVolume ? (lightNode->GetWorldPosition() -
cameraEffectivePos) : lightNode->GetWorldPosition()), atten));
if (graphics->HasShaderParameter(PS, PSP_LIGHTMATRICES))
{
switch (light->GetLightType())
{
case LIGHT_DIRECTIONAL:
{
Matrix4 shadowMatrices[MAX_CASCADE_SPLITS];
unsigned numSplits = lightQueue_->shadowSplits_.Size();
for (unsigned i = 0; i < numSplits; ++i)
{
CalculateShadowMatrix(shadowMatrices[i], lightQueue_, i, renderer, isLightVolume ? cameraEffectivePos :
Vector3::ZERO);
}
graphics->SetShaderParameter(PSP_LIGHTMATRICES, shadowMatrices[0].Data(), 16 * numSplits);
}
break;
case LIGHT_SPOT:
{
Matrix4 shadowMatrices[2];
CalculateSpotMatrix(shadowMatrices[0], light, cameraEffectivePos);
bool isShadowed = lightQueue_->shadowMap_ != 0;
if (isShadowed)
{
CalculateShadowMatrix(shadowMatrices[1], lightQueue_, 0, renderer, isLightVolume ? cameraEffectivePos :
Vector3::ZERO);
}
graphics->SetShaderParameter(PSP_LIGHTMATRICES, shadowMatrices[0].Data(), isShadowed ? 32 : 16);
}
break;
case LIGHT_POINT:
{
Matrix4 lightVecRot(lightNode->GetWorldRotation().RotationMatrix());
// HLSL compiler will pack the parameters as if the matrix is only 3x4, so must be careful to not overwrite
// the next parameter
#ifdef URHO3D_OPENGL
graphics->SetShaderParameter(PSP_LIGHTMATRICES, lightVecRot.Data(), 16);
#else
graphics->SetShaderParameter(PSP_LIGHTMATRICES, lightVecRot.Data(), 12);
#endif
}
break;
}
}
// Set shadow mapping shader parameters
if (shadowMap)
{
{
// Calculate point light shadow sampling offsets (unrolled cube map)
unsigned faceWidth = shadowMap->GetWidth() / 2;
unsigned faceHeight = shadowMap->GetHeight() / 3;
float width = (float)shadowMap->GetWidth();
float height = (float)shadowMap->GetHeight();
#ifdef URHO3D_OPENGL
float mulX = (float)(faceWidth - 3) / width;
float mulY = (float)(faceHeight - 3) / height;
float addX = 1.5f / width;
float addY = 1.5f / height;
#else
float mulX = (float)(faceWidth - 4) / width;
float mulY = (float)(faceHeight - 4) / height;
float addX = 2.5f / width;
float addY = 2.5f / height;
#endif
// If using 4 shadow samples, offset the position diagonally by half pixel
if (renderer->GetShadowQuality() & SHADOWQUALITY_HIGH_16BIT)
{
addX -= 0.5f / width;
addY -= 0.5f / height;
}
graphics->SetShaderParameter(PSP_SHADOWCUBEADJUST, Vector4(mulX, mulY, addX, addY));
}
{
// Calculate shadow camera depth parameters for point light shadows and shadow fade parameters for
// directional light shadows, stored in the same uniform
Camera* shadowCamera = lightQueue_->shadowSplits_[0].shadowCamera_;
float nearClip = shadowCamera->GetNearClip();
float farClip = shadowCamera->GetFarClip();
float q = farClip / (farClip - nearClip);
float r = -q * nearClip;
const CascadeParameters& parameters = light->GetShadowCascade();
float viewFarClip = camera_->GetFarClip();
float shadowRange = parameters.GetShadowRange();
float fadeStart = parameters.fadeStart_ * shadowRange / viewFarClip;
float fadeEnd = shadowRange / viewFarClip;
float fadeRange = fadeEnd - fadeStart;
graphics->SetShaderParameter(PSP_SHADOWDEPTHFADE, Vector4(q, r, fadeStart, 1.0f / fadeRange));
}
{
float intensity = light->GetShadowIntensity();
float fadeStart = light->GetShadowFadeDistance();
float fadeEnd = light->GetShadowDistance();
if (fadeStart > 0.0f && fadeEnd > 0.0f && fadeEnd > fadeStart)
intensity = Lerp(intensity, 1.0f, Clamp((light->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 0.0f, 1.0f));
float pcfValues = (1.0f - intensity);
float samples = renderer->GetShadowQuality() >= SHADOWQUALITY_HIGH_16BIT ? 4.0f : 1.0f;
graphics->SetShaderParameter(PSP_SHADOWINTENSITY, Vector4(pcfValues / samples, intensity, 0.0f, 0.0f));
}
float sizeX = 1.0f / (float)shadowMap->GetWidth();
float sizeY = 1.0f / (float)shadowMap->GetHeight();
graphics->SetShaderParameter(PSP_SHADOWMAPINVSIZE, Vector4(sizeX, sizeY, 0.0f, 0.0f));
Vector4 lightSplits(M_LARGE_VALUE, M_LARGE_VALUE, M_LARGE_VALUE, M_LARGE_VALUE);
if (lightQueue_->shadowSplits_.Size() > 1)
lightSplits.x_ = lightQueue_->shadowSplits_[0].farSplit_ / camera_->GetFarClip();
if (lightQueue_->shadowSplits_.Size() > 2)
lightSplits.y_ = lightQueue_->shadowSplits_[1].farSplit_ / camera_->GetFarClip();
if (lightQueue_->shadowSplits_.Size() > 3)
lightSplits.z_ = lightQueue_->shadowSplits_[2].farSplit_ / camera_->GetFarClip();
graphics->SetShaderParameter(PSP_SHADOWSPLITS, lightSplits);
}
}
// Set material-specific shader parameters and textures
if (material_)
{
if (graphics->NeedParameterUpdate(SP_MATERIAL, material_))
{
const HashMap<StringHash, MaterialShaderParameter>& parameters = material_->GetShaderParameters();
for (HashMap<StringHash, MaterialShaderParameter>::ConstIterator i = parameters.Begin(); i != parameters.End(); ++i)
graphics->SetShaderParameter(i->first_, i->second_.value_);
}
const SharedPtr<Texture>* textures = material_->GetTextures();
unsigned numTextures = material_->GetNumUsedTextureUnits();
for (unsigned i = 0; i < numTextures; ++i)
{
TextureUnit unit = (TextureUnit)i;
if (textures[i] && graphics->HasTextureUnit(unit))
graphics->SetTexture(i, textures[i]);
}
}
// Set light-related textures
if (light)
{
if (shadowMap && graphics->HasTextureUnit(TU_SHADOWMAP))
graphics->SetTexture(TU_SHADOWMAP, shadowMap);
if (graphics->HasTextureUnit(TU_LIGHTRAMP))
{
Texture* rampTexture = light->GetRampTexture();
if (!rampTexture)
rampTexture = renderer->GetDefaultLightRamp();
graphics->SetTexture(TU_LIGHTRAMP, rampTexture);
}
if (graphics->HasTextureUnit(TU_LIGHTSHAPE))
{
Texture* shapeTexture = light->GetShapeTexture();
if (!shapeTexture && light->GetLightType() == LIGHT_SPOT)
shapeTexture = renderer->GetDefaultLightSpot();
graphics->SetTexture(TU_LIGHTSHAPE, shapeTexture);
}
}
// Set zone texture if necessary
if (zone_ && graphics->HasTextureUnit(TU_ZONE))
graphics->SetTexture(TU_ZONE, zone_->GetZoneTexture());
}
void Batch::Draw(View* view) const
{
if (!geometry_->IsEmpty())
{
Prepare(view);
geometry_->Draw(view->GetGraphics());
}
}
void BatchGroup::SetTransforms(void* lockedData, unsigned& freeIndex)
{
// Do not use up buffer space if not going to draw as instanced
if (geometryType_ != GEOM_INSTANCED)
return;
startIndex_ = freeIndex;
Matrix3x4* dest = (Matrix3x4*)lockedData;
dest += freeIndex;
for (unsigned i = 0; i < instances_.Size(); ++i)
*dest++ = *instances_[i].worldTransform_;
freeIndex += instances_.Size();
}
void BatchGroup::Draw(View* view) const
{
Graphics* graphics = view->GetGraphics();
Renderer* renderer = view->GetRenderer();
if (instances_.Size() && !geometry_->IsEmpty())
{
// Draw as individual objects if instancing not supported
VertexBuffer* instanceBuffer = renderer->GetInstancingBuffer();
if (!instanceBuffer || geometryType_ != GEOM_INSTANCED)
{
Batch::Prepare(view, false);
graphics->SetIndexBuffer(geometry_->GetIndexBuffer());
graphics->SetVertexBuffers(geometry_->GetVertexBuffers(), geometry_->GetVertexElementMasks());
for (unsigned i = 0; i < instances_.Size(); ++i)
{
if (graphics->NeedParameterUpdate(SP_OBJECTTRANSFORM, instances_[i].worldTransform_))
graphics->SetShaderParameter(VSP_MODEL, *instances_[i].worldTransform_);
graphics->Draw(geometry_->GetPrimitiveType(), geometry_->GetIndexStart(), geometry_->GetIndexCount(),
geometry_->GetVertexStart(), geometry_->GetVertexCount());
}
}
else
{
Batch::Prepare(view, false);
// Get the geometry vertex buffers, then add the instancing stream buffer
// Hack: use a const_cast to avoid dynamic allocation of new temp vectors
Vector<SharedPtr<VertexBuffer> >& vertexBuffers = const_cast<Vector<SharedPtr<VertexBuffer> >&>
(geometry_->GetVertexBuffers());
PODVector<unsigned>& elementMasks = const_cast<PODVector<unsigned>&>(geometry_->GetVertexElementMasks());
vertexBuffers.Push(SharedPtr<VertexBuffer>(instanceBuffer));
elementMasks.Push(instanceBuffer->GetElementMask());
// No stream offset support, instancing buffer not pre-filled with transforms: have to fill now
if (startIndex_ == M_MAX_UNSIGNED)
{
unsigned startIndex = 0;
while (startIndex < instances_.Size())
{
unsigned instances = instances_.Size() - startIndex;
if (instances > instanceBuffer->GetVertexCount())
instances = instanceBuffer->GetVertexCount();
// Copy the transforms
Matrix3x4* dest = (Matrix3x4*)instanceBuffer->Lock(0, instances, true);
if (dest)
{
for (unsigned i = 0; i < instances; ++i)
dest[i] = *instances_[i + startIndex].worldTransform_;
instanceBuffer->Unlock();
graphics->SetIndexBuffer(geometry_->GetIndexBuffer());
graphics->SetVertexBuffers(vertexBuffers, elementMasks);
graphics->DrawInstanced(geometry_->GetPrimitiveType(), geometry_->GetIndexStart(),
geometry_->GetIndexCount(), geometry_->GetVertexStart(), geometry_->GetVertexCount(), instances);
}
startIndex += instances;
}
}
// Stream offset supported and instancing buffer has been already filled, so just draw
else
{
graphics->SetIndexBuffer(geometry_->GetIndexBuffer());
graphics->SetVertexBuffers(vertexBuffers, elementMasks, startIndex_);
graphics->DrawInstanced(geometry_->GetPrimitiveType(), geometry_->GetIndexStart(), geometry_->GetIndexCount(),
geometry_->GetVertexStart(), geometry_->GetVertexCount(), instances_.Size());
}
// Remove the instancing buffer & element mask now
vertexBuffers.Pop();
elementMasks.Pop();
}
}
}
unsigned BatchGroupKey::ToHash() const
{
return ((unsigned)(size_t)zone_) / sizeof(Zone) +
((unsigned)(size_t)lightQueue_) / sizeof(LightBatchQueue) +
((unsigned)(size_t)pass_) / sizeof(Pass) +
((unsigned)(size_t)material_) / sizeof(Material) +
((unsigned)(size_t)geometry_) / sizeof(Geometry);
}
void BatchQueue::Clear(int maxSortedInstances)
{
batches_.Clear();
sortedBatches_.Clear();
batchGroups_.Clear();
maxSortedInstances_ = maxSortedInstances;
}
void BatchQueue::SortBackToFront()
{
sortedBatches_.Resize(batches_.Size());
for (unsigned i = 0; i < batches_.Size(); ++i)
sortedBatches_[i] = &batches_[i];
Sort(sortedBatches_.Begin(), sortedBatches_.End(), CompareBatchesBackToFront);
// Do not actually sort batch groups, just list them
sortedBatchGroups_.Resize(batchGroups_.Size());
unsigned index = 0;
for (HashMap<BatchGroupKey, BatchGroup>::Iterator i = batchGroups_.Begin(); i != batchGroups_.End(); ++i)
sortedBatchGroups_[index++] = &i->second_;
}
void BatchQueue::SortFrontToBack()
{
sortedBatches_.Clear();
for (unsigned i = 0; i < batches_.Size(); ++i)
sortedBatches_.Push(&batches_[i]);
SortFrontToBack2Pass(sortedBatches_);
// Sort each group front to back
for (HashMap<BatchGroupKey, BatchGroup>::Iterator i = batchGroups_.Begin(); i != batchGroups_.End(); ++i)
{
if (i->second_.instances_.Size() <= maxSortedInstances_)
{
Sort(i->second_.instances_.Begin(), i->second_.instances_.End(), CompareInstancesFrontToBack);
if (i->second_.instances_.Size())
i->second_.distance_ = i->second_.instances_[0].distance_;
}
else
{
float minDistance = M_INFINITY;
for (PODVector<InstanceData>::ConstIterator j = i->second_.instances_.Begin(); j != i->second_.instances_.End(); ++j)
minDistance = Min(minDistance, j->distance_);
i->second_.distance_ = minDistance;
}
}
sortedBatchGroups_.Resize(batchGroups_.Size());
unsigned index = 0;
for (HashMap<BatchGroupKey, BatchGroup>::Iterator i = batchGroups_.Begin(); i != batchGroups_.End(); ++i)
sortedBatchGroups_[index++] = &i->second_;
SortFrontToBack2Pass(reinterpret_cast<PODVector<Batch*>& >(sortedBatchGroups_));
}
void BatchQueue::SortFrontToBack2Pass(PODVector<Batch*>& batches)
{
// Mobile devices likely use a tiled deferred approach, with which front-to-back sorting is irrelevant. The 2-pass
// method is also time consuming, so just sort with state having priority
#ifdef GL_ES_VERSION_2_0
Sort(batches.Begin(), batches.End(), CompareBatchesState);
#else
// For desktop, first sort by distance and remap shader/material/geometry IDs in the sort key
Sort(batches.Begin(), batches.End(), CompareBatchesFrontToBack);
unsigned freeShaderID = 0;
unsigned short freeMaterialID = 0;
unsigned short freeGeometryID = 0;
for (PODVector<Batch*>::Iterator i = batches.Begin(); i != batches.End(); ++i)
{
Batch* batch = *i;
unsigned shaderID = (batch->sortKey_ >> 32);
HashMap<unsigned, unsigned>::ConstIterator j = shaderRemapping_.Find(shaderID);
if (j != shaderRemapping_.End())
shaderID = j->second_;
else
{
shaderID = shaderRemapping_[shaderID] = freeShaderID | (shaderID & 0xc0000000);
++freeShaderID;
}
unsigned short materialID = (unsigned short)(batch->sortKey_ & 0xffff0000);
HashMap<unsigned short, unsigned short>::ConstIterator k = materialRemapping_.Find(materialID);
if (k != materialRemapping_.End())
materialID = k->second_;
else
{
materialID = materialRemapping_[materialID] = freeMaterialID;
++freeMaterialID;
}
unsigned short geometryID = (unsigned short)(batch->sortKey_ & 0xffff);
HashMap<unsigned short, unsigned short>::ConstIterator l = geometryRemapping_.Find(geometryID);
if (l != geometryRemapping_.End())
geometryID = l->second_;
else
{
geometryID = geometryRemapping_[geometryID] = freeGeometryID;
++freeGeometryID;
}
batch->sortKey_ = (((unsigned long long)shaderID) << 32) || (((unsigned long long)materialID) << 16) | geometryID;
}
shaderRemapping_.Clear();
materialRemapping_.Clear();
geometryRemapping_.Clear();
// Finally sort again with the rewritten ID's
Sort(batches.Begin(), batches.End(), CompareBatchesState);
#endif
}
void BatchQueue::SetTransforms(void* lockedData, unsigned& freeIndex)
{
for (HashMap<BatchGroupKey, BatchGroup>::Iterator i = batchGroups_.Begin(); i != batchGroups_.End(); ++i)
i->second_.SetTransforms(lockedData, freeIndex);
}
void BatchQueue::Draw(View* view, bool markToStencil, bool usingLightOptimization) const
{
Graphics* graphics = view->GetGraphics();
Renderer* renderer = view->GetRenderer();
// If View has set up its own light optimizations, do not disturb the stencil/scissor test settings
if (!usingLightOptimization)
{
graphics->SetScissorTest(false);
// During G-buffer rendering, mark opaque pixels' lightmask to stencil buffer if requested
if (!markToStencil)
graphics->SetStencilTest(false);
}
// Instanced
for (PODVector<BatchGroup*>::ConstIterator i = sortedBatchGroups_.Begin(); i != sortedBatchGroups_.End(); ++i)
{
BatchGroup* group = *i;
if (markToStencil)
graphics->SetStencilTest(true, CMP_ALWAYS, OP_REF, OP_KEEP, OP_KEEP, group->lightMask_);
group->Draw(view);
}
// Non-instanced
for (PODVector<Batch*>::ConstIterator i = sortedBatches_.Begin(); i != sortedBatches_.End(); ++i)
{
Batch* batch = *i;
if (markToStencil)
graphics->SetStencilTest(true, CMP_ALWAYS, OP_REF, OP_KEEP, OP_KEEP, batch->lightMask_);
if (!usingLightOptimization)
{
// If drawing an alpha batch, we can optimize fillrate by scissor test
if (!batch->isBase_ && batch->lightQueue_)
renderer->OptimizeLightByScissor(batch->lightQueue_->light_, batch->camera_);
else
graphics->SetScissorTest(false);
}
batch->Draw(view);
}
}
unsigned BatchQueue::GetNumInstances() const
{
unsigned total = 0;
for (HashMap<BatchGroupKey, BatchGroup>::ConstIterator i = batchGroups_.Begin(); i != batchGroups_.End(); ++i)
{
if (i->second_.geometryType_ == GEOM_INSTANCED)
total += i->second_.instances_.Size();
}
return total;
}
}
| 42.96868 | 151 | 0.58726 | vivienneanthony |
29c6556318ec49e1a9987261477276e9dad98234 | 763 | cpp | C++ | server/Common/Packets/CGExchangeSynchLock.cpp | viticm/web-pap | 7c9b1f49d9ba8d8e40f8fddae829c2e414ccfeca | [
"BSD-3-Clause"
] | 3 | 2018-06-19T21:37:38.000Z | 2021-07-31T21:51:40.000Z | server/Common/Packets/CGExchangeSynchLock.cpp | viticm/web-pap | 7c9b1f49d9ba8d8e40f8fddae829c2e414ccfeca | [
"BSD-3-Clause"
] | null | null | null | server/Common/Packets/CGExchangeSynchLock.cpp | viticm/web-pap | 7c9b1f49d9ba8d8e40f8fddae829c2e414ccfeca | [
"BSD-3-Clause"
] | 13 | 2015-01-30T17:45:06.000Z | 2022-01-06T02:29:34.000Z | #include "stdafx.h"
// CGExchangeSynchLock.cpp
//
/////////////////////////////////////////////////////
#include "CGExchangeSynchLock.h"
BOOL CGExchangeSynchLock::Read( SocketInputStream& iStream )
{
__ENTER_FUNCTION
iStream.Read( (CHAR*)(&m_LockMyself), sizeof(BYTE));
return TRUE ;
__LEAVE_FUNCTION
return FALSE ;
}
BOOL CGExchangeSynchLock::Write( SocketOutputStream& oStream )const
{
__ENTER_FUNCTION
oStream.Write( (CHAR*)(&m_LockMyself), sizeof(BYTE));
return TRUE ;
__LEAVE_FUNCTION
return FALSE ;
}
UINT CGExchangeSynchLock::Execute( Player* pPlayer )
{
__ENTER_FUNCTION
return CGExchangeSynchLockHandler::Execute( this, pPlayer ) ;
__LEAVE_FUNCTION
return FALSE ;
}
| 17.744186 | 69 | 0.640891 | viticm |
29c92b1188c4b68727cda03546847de96db4fc54 | 4,485 | cpp | C++ | VisualPipes/albaPipeScalarMatrix.cpp | IOR-BIC/ALBA | b574968b05d9a3a2756dd2ac61d015a0d20232a4 | [
"Apache-2.0",
"BSD-3-Clause"
] | 9 | 2018-11-19T10:15:29.000Z | 2021-08-30T11:52:07.000Z | VisualPipes/albaPipeScalarMatrix.cpp | IOR-BIC/ALBA | b574968b05d9a3a2756dd2ac61d015a0d20232a4 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | VisualPipes/albaPipeScalarMatrix.cpp | IOR-BIC/ALBA | b574968b05d9a3a2756dd2ac61d015a0d20232a4 | [
"Apache-2.0",
"BSD-3-Clause"
] | 3 | 2018-06-10T22:56:29.000Z | 2019-12-12T06:22:56.000Z | /*=========================================================================
Program: ALBA (Agile Library for Biomedical Applications)
Module: albaPipeScalarMatrix
Authors: Paolo Quadrani
Copyright (c) BIC
All rights reserved. See Copyright.txt or
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "albaDefines.h"
//----------------------------------------------------------------------------
// NOTE: Every CPP file in the ALBA must include "albaDefines.h" as first.
// This force to include Window,wxWidgets and VTK exactly in this order.
// Failing in doing this will result in a run-time error saying:
// "Failure#0: The value of ESP was not properly saved across a function call"
//----------------------------------------------------------------------------
#include "albaPipeScalarMatrix.h"
#include "albaPipeScalarMatrix.h"
#include "albaDecl.h"
#include "albaSceneNode.h"
#include "albaGUI.h"
#include "albaVME.h"
#include "albaVMEOutputScalarMatrix.h"
#include "albaVMEScalarMatrix.h"
#include "albaTagItem.h"
#include "albaTagArray.h"
#include "vtkALBASmartPointer.h"
#include "vtkALBAAssembly.h"
#include "vtkRenderer.h"
#include "vtkPolyDataMapper.h"
#include "vtkTextProperty.h"
#include "vtkCubeAxesActor2D.h"
#include "vtkPolyData.h"
#include "vtkActor.h"
//----------------------------------------------------------------------------
albaCxxTypeMacro(albaPipeScalarMatrix);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
albaPipeScalarMatrix::albaPipeScalarMatrix()
:albaPipe()
//----------------------------------------------------------------------------
{
m_CubeAxes = NULL;
m_Actor = NULL;
}
//----------------------------------------------------------------------------
void albaPipeScalarMatrix::Create(albaSceneNode *n)
//----------------------------------------------------------------------------
{
Superclass::Create(n);
m_Selected = false;
vtkDataSet *ds = m_Vme->GetOutput()->GetVTKData();
vtkALBASmartPointer<vtkTextProperty> tprop;
tprop->SetColor(1, 1, 1);
tprop->ShadowOn();
vtkALBASmartPointer<vtkPolyDataMapper> mapper;
mapper->SetInput((vtkPolyData *)ds);
mapper->ScalarVisibilityOn();
mapper->SetScalarRange(ds->GetScalarRange());
vtkNEW(m_Actor);
m_Actor->SetMapper(mapper);
m_AssemblyFront->AddPart(m_Actor);
vtkNEW(m_CubeAxes);
m_CubeAxes->SetInput(ds);
m_CubeAxes->SetCamera(m_RenFront->GetActiveCamera());
m_CubeAxes->SetLabelFormat("%6.4g");
m_CubeAxes->SetNumberOfLabels(5);
m_CubeAxes->SetFlyModeToOuterEdges();
m_CubeAxes->SetFontFactor(0.4);
m_CubeAxes->SetAxisTitleTextProperty(tprop);
m_CubeAxes->SetAxisLabelTextProperty(tprop);
m_RenFront->AddActor2D(m_CubeAxes);
}
//----------------------------------------------------------------------------
albaPipeScalarMatrix::~albaPipeScalarMatrix()
//----------------------------------------------------------------------------
{
m_RenFront->RemoveActor2D(m_CubeAxes);
vtkDEL(m_CubeAxes);
m_AssemblyFront->RemovePart(m_Actor);
vtkDEL(m_Actor);
}
//----------------------------------------------------------------------------
void albaPipeScalarMatrix::Select(bool sel)
//----------------------------------------------------------------------------
{
m_Selected = sel;
}
//----------------------------------------------------------------------------
albaGUI *albaPipeScalarMatrix::CreateGui()
//----------------------------------------------------------------------------
{
m_Gui = new albaGUI(this);
m_Gui->Divider();
return m_Gui;
}
//----------------------------------------------------------------------------
void albaPipeScalarMatrix::OnEvent(albaEventBase *alba_event)
//----------------------------------------------------------------------------
{
if (albaEvent *e = albaEvent::SafeDownCast(alba_event))
{
switch(e->GetId())
{
case ID_RADIUS:
break;
}
GetLogicManager()->CameraUpdate();
}
}
//----------------------------------------------------------------------------
void albaPipeScalarMatrix::UpdateProperty(bool fromTag)
//----------------------------------------------------------------------------
{
}
| 32.266187 | 78 | 0.488294 | IOR-BIC |
29cb02559dfeefadabe73336607fde83fe317c53 | 8,333 | ipp | C++ | implement/oglplus/enums/texture_target_def.ipp | matus-chochlik/oglplus | 76dd964e590967ff13ddff8945e9dcf355e0c952 | [
"BSL-1.0"
] | 364 | 2015-01-01T09:38:23.000Z | 2022-03-22T05:32:00.000Z | implement/oglplus/enums/texture_target_def.ipp | matus-chochlik/oglplus | 76dd964e590967ff13ddff8945e9dcf355e0c952 | [
"BSL-1.0"
] | 55 | 2015-01-06T16:42:55.000Z | 2020-07-09T04:21:41.000Z | implement/oglplus/enums/texture_target_def.ipp | matus-chochlik/oglplus | 76dd964e590967ff13ddff8945e9dcf355e0c952 | [
"BSL-1.0"
] | 57 | 2015-01-07T18:35:49.000Z | 2022-03-22T05:32:04.000Z | // File implement/oglplus/enums/texture_target_def.ipp
//
// Automatically generated file, DO NOT modify manually.
// Edit the source 'source/enums/oglplus/texture_target.txt'
// or the 'source/enums/make_enum.py' script instead.
//
// Copyright 2010-2019 Matus Chochlik.
// 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
//
#ifdef OGLPLUS_LIST_NEEDS_COMMA
# undef OGLPLUS_LIST_NEEDS_COMMA
#endif
#if defined GL_TEXTURE_1D
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined _1D
# pragma push_macro("_1D")
# undef _1D
OGLPLUS_ENUM_CLASS_VALUE(_1D, GL_TEXTURE_1D)
# pragma pop_macro("_1D")
# else
OGLPLUS_ENUM_CLASS_VALUE(_1D, GL_TEXTURE_1D)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_2D
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined _2D
# pragma push_macro("_2D")
# undef _2D
OGLPLUS_ENUM_CLASS_VALUE(_2D, GL_TEXTURE_2D)
# pragma pop_macro("_2D")
# else
OGLPLUS_ENUM_CLASS_VALUE(_2D, GL_TEXTURE_2D)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_3D
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined _3D
# pragma push_macro("_3D")
# undef _3D
OGLPLUS_ENUM_CLASS_VALUE(_3D, GL_TEXTURE_3D)
# pragma pop_macro("_3D")
# else
OGLPLUS_ENUM_CLASS_VALUE(_3D, GL_TEXTURE_3D)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_1D_ARRAY
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined _1DArray
# pragma push_macro("_1DArray")
# undef _1DArray
OGLPLUS_ENUM_CLASS_VALUE(_1DArray, GL_TEXTURE_1D_ARRAY)
# pragma pop_macro("_1DArray")
# else
OGLPLUS_ENUM_CLASS_VALUE(_1DArray, GL_TEXTURE_1D_ARRAY)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_2D_ARRAY
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined _2DArray
# pragma push_macro("_2DArray")
# undef _2DArray
OGLPLUS_ENUM_CLASS_VALUE(_2DArray, GL_TEXTURE_2D_ARRAY)
# pragma pop_macro("_2DArray")
# else
OGLPLUS_ENUM_CLASS_VALUE(_2DArray, GL_TEXTURE_2D_ARRAY)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_RECTANGLE
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined Rectangle
# pragma push_macro("Rectangle")
# undef Rectangle
OGLPLUS_ENUM_CLASS_VALUE(Rectangle, GL_TEXTURE_RECTANGLE)
# pragma pop_macro("Rectangle")
# else
OGLPLUS_ENUM_CLASS_VALUE(Rectangle, GL_TEXTURE_RECTANGLE)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_BUFFER
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined Buffer
# pragma push_macro("Buffer")
# undef Buffer
OGLPLUS_ENUM_CLASS_VALUE(Buffer, GL_TEXTURE_BUFFER)
# pragma pop_macro("Buffer")
# else
OGLPLUS_ENUM_CLASS_VALUE(Buffer, GL_TEXTURE_BUFFER)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_CUBE_MAP
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined CubeMap
# pragma push_macro("CubeMap")
# undef CubeMap
OGLPLUS_ENUM_CLASS_VALUE(CubeMap, GL_TEXTURE_CUBE_MAP)
# pragma pop_macro("CubeMap")
# else
OGLPLUS_ENUM_CLASS_VALUE(CubeMap, GL_TEXTURE_CUBE_MAP)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_CUBE_MAP_ARRAY
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined CubeMapArray
# pragma push_macro("CubeMapArray")
# undef CubeMapArray
OGLPLUS_ENUM_CLASS_VALUE(CubeMapArray, GL_TEXTURE_CUBE_MAP_ARRAY)
# pragma pop_macro("CubeMapArray")
# else
OGLPLUS_ENUM_CLASS_VALUE(CubeMapArray, GL_TEXTURE_CUBE_MAP_ARRAY)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_2D_MULTISAMPLE
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined _2DMultisample
# pragma push_macro("_2DMultisample")
# undef _2DMultisample
OGLPLUS_ENUM_CLASS_VALUE(_2DMultisample, GL_TEXTURE_2D_MULTISAMPLE)
# pragma pop_macro("_2DMultisample")
# else
OGLPLUS_ENUM_CLASS_VALUE(_2DMultisample, GL_TEXTURE_2D_MULTISAMPLE)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_2D_MULTISAMPLE_ARRAY
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined _2DMultisampleArray
# pragma push_macro("_2DMultisampleArray")
# undef _2DMultisampleArray
OGLPLUS_ENUM_CLASS_VALUE(_2DMultisampleArray, GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
# pragma pop_macro("_2DMultisampleArray")
# else
OGLPLUS_ENUM_CLASS_VALUE(_2DMultisampleArray, GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_CUBE_MAP_POSITIVE_X
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined CubeMapPositiveX
# pragma push_macro("CubeMapPositiveX")
# undef CubeMapPositiveX
OGLPLUS_ENUM_CLASS_VALUE(CubeMapPositiveX, GL_TEXTURE_CUBE_MAP_POSITIVE_X)
# pragma pop_macro("CubeMapPositiveX")
# else
OGLPLUS_ENUM_CLASS_VALUE(CubeMapPositiveX, GL_TEXTURE_CUBE_MAP_POSITIVE_X)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_CUBE_MAP_NEGATIVE_X
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined CubeMapNegativeX
# pragma push_macro("CubeMapNegativeX")
# undef CubeMapNegativeX
OGLPLUS_ENUM_CLASS_VALUE(CubeMapNegativeX, GL_TEXTURE_CUBE_MAP_NEGATIVE_X)
# pragma pop_macro("CubeMapNegativeX")
# else
OGLPLUS_ENUM_CLASS_VALUE(CubeMapNegativeX, GL_TEXTURE_CUBE_MAP_NEGATIVE_X)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_CUBE_MAP_POSITIVE_Y
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined CubeMapPositiveY
# pragma push_macro("CubeMapPositiveY")
# undef CubeMapPositiveY
OGLPLUS_ENUM_CLASS_VALUE(CubeMapPositiveY, GL_TEXTURE_CUBE_MAP_POSITIVE_Y)
# pragma pop_macro("CubeMapPositiveY")
# else
OGLPLUS_ENUM_CLASS_VALUE(CubeMapPositiveY, GL_TEXTURE_CUBE_MAP_POSITIVE_Y)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined CubeMapNegativeY
# pragma push_macro("CubeMapNegativeY")
# undef CubeMapNegativeY
OGLPLUS_ENUM_CLASS_VALUE(CubeMapNegativeY, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y)
# pragma pop_macro("CubeMapNegativeY")
# else
OGLPLUS_ENUM_CLASS_VALUE(CubeMapNegativeY, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_CUBE_MAP_POSITIVE_Z
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined CubeMapPositiveZ
# pragma push_macro("CubeMapPositiveZ")
# undef CubeMapPositiveZ
OGLPLUS_ENUM_CLASS_VALUE(CubeMapPositiveZ, GL_TEXTURE_CUBE_MAP_POSITIVE_Z)
# pragma pop_macro("CubeMapPositiveZ")
# else
OGLPLUS_ENUM_CLASS_VALUE(CubeMapPositiveZ, GL_TEXTURE_CUBE_MAP_POSITIVE_Z)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#if defined GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
# ifdef OGLPLUS_LIST_NEEDS_COMMA
OGLPLUS_ENUM_CLASS_COMMA
# endif
# if defined CubeMapNegativeZ
# pragma push_macro("CubeMapNegativeZ")
# undef CubeMapNegativeZ
OGLPLUS_ENUM_CLASS_VALUE(CubeMapNegativeZ, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z)
# pragma pop_macro("CubeMapNegativeZ")
# else
OGLPLUS_ENUM_CLASS_VALUE(CubeMapNegativeZ, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z)
# endif
# ifndef OGLPLUS_LIST_NEEDS_COMMA
# define OGLPLUS_LIST_NEEDS_COMMA 1
# endif
#endif
#ifdef OGLPLUS_LIST_NEEDS_COMMA
# undef OGLPLUS_LIST_NEEDS_COMMA
#endif
| 28.537671 | 81 | 0.821193 | matus-chochlik |
29cb9bda569af1c89cd33edd8f27f22927003c2d | 1,407 | cpp | C++ | codechef/BORDER/Partially Accepted.cpp | kzvd4729/Problem-Solving | 13b105e725a4c2f8db7fecc5d7a8f932b9fef4ab | [
"MIT"
] | 1 | 2022-02-11T16:55:36.000Z | 2022-02-11T16:55:36.000Z | codechef/BORDER/Partially Accepted.cpp | kzvd4729/Problem-Solving | 13b105e725a4c2f8db7fecc5d7a8f932b9fef4ab | [
"MIT"
] | null | null | null | codechef/BORDER/Partially Accepted.cpp | kzvd4729/Problem-Solving | 13b105e725a4c2f8db7fecc5d7a8f932b9fef4ab | [
"MIT"
] | null | null | null | /****************************************************************************************
* @author: kzvd4729 created: 24-02-2018 21:46:36
* solution_verdict: Partially Accepted language: C++14
* run_time: 0.26 sec memory_used: 15.7M
* problem: https://www.codechef.com/LTIME57/problems/BORDER
****************************************************************************************/
#include<bits/stdc++.h>
#define long long long
using namespace std;
long n,q,t,f,x,nm;
string ss,s;
vector<long>v[505];
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin>>t;
while(t--)
{
cin>>n>>q;
for(long i=1;i<=n;i++)v[i].clear();
cin>>ss;
for(long i=1;i<=n;i++)
{
s=ss.substr(0,i);
for(long j=1;j<=s.size();j++)
{
f=0;
for(long k=0,kk=s.size()-j;k<j;k++,kk++)
{
if(s[k]!=s[kk])f=1;
}
if(!f)v[i].push_back(j);
}
}
while(q--)
{
cin>>x>>nm;
if(v[x].size()<nm)cout<<-1<<endl;
else cout<<v[x][nm-1]<<endl;
}
}
return 0;
} | 31.266667 | 111 | 0.331912 | kzvd4729 |
29cba758c0d9e84f6cc60326fe2cf37a8d1b40e5 | 17,293 | cpp | C++ | Hacks/skinconfigchanger.cpp | manigamer22/Killersupdate | add145ffe5ed8121e6dffcecae2bd9e0885f4a2e | [
"Unlicense"
] | 2 | 2020-05-15T16:05:03.000Z | 2021-09-17T04:07:54.000Z | Hacks/skinconfigchanger.cpp | manigamer22/MacTap | 9a48bffe5faec86d0edc4a79e620d27b674c510c | [
"Unlicense"
] | 3 | 2020-11-09T14:05:01.000Z | 2021-09-01T05:37:56.000Z | Hacks/skinconfigchanger.cpp | manigamer22/MacTap | 9a48bffe5faec86d0edc4a79e620d27b674c510c | [
"Unlicense"
] | 1 | 2021-09-17T04:07:19.000Z | 2021-09-17T04:07:19.000Z | #include "skinconfigchanger.hpp"
int KnifeCT = WEAPON_KNIFE_SKELETON;
int KnifeT = WEAPON_KNIFE_SKELETON;
int GloveCT = GLOVE_MOTORCYCLE;
int GloveT = GLOVE_MOTORCYCLE;
unordered_map<int, cSkin> cSkinchanger::Skins = unordered_map<int, cSkin>( {
//knife
make_pair(WEAPON_KNIFE, cSkin(59, -1, KnifeCT, -1, 3, nullptr, 0.00000000001f)),
make_pair(WEAPON_KNIFE_T, cSkin(59, -1, KnifeCT, -1, 3, nullptr, 0.00000000001f)),
//glove
make_pair(GLOVE_CT, cSkin(10026, -1, GloveCT, -1, 3, nullptr, 0.00000000001f)),
make_pair(GLOVE_T, cSkin(10026, -1, GloveT, -1, 3, nullptr, 0.00000000001f)),
//guns
make_pair(WEAPON_AWP, cSkin(756, -1, -1, -1, 0, nullptr, 0.00000000001f)),
make_pair(WEAPON_SSG08, cSkin(899, -1, -1, -1, 0, nullptr, 0.00000000001f)),
make_pair(WEAPON_MAC10, cSkin(898, -1, -1, -1, 0, nullptr, 0.00000000001f)),
make_pair(WEAPON_SG556, cSkin(897, -1, -1, -1, 0, nullptr, 0.00000000001f)),
make_pair(WEAPON_MP7, cSkin(893, -1, -1, -1, 0, nullptr, 0.00000000001f)),
});
unordered_map<int, const char*> cSkinchanger::ModelList;
std::unique_ptr<RecvPropHook> SkinChanger::sequenceHook;
cSkinchanger* skinchanger = new cSkinchanger;
void cSkinchanger::FrameStageNotify(ClientFrameStage_t stage) {
if(stage == FRAME_NET_UPDATE_POSTDATAUPDATE_START){
pLocalPlayer = (C_BaseEntity*)(pEntList->GetClientEntity(pEngine->GetLocalPlayer()));
if(pLocalPlayer && pLocalPlayer->GetHealth() > 0){
if(!bInit){
Init();
bInit = true;
}
ForceSkins();
}
}
}
void cSkinchanger::FindModels() {
ModelList[pModelInfo->GetModelIndex("models/weapons/v_knife_default_ct.mdl")] = KnifeToModelMatrix[KnifeCT].c_str();
ModelList[pModelInfo->GetModelIndex("models/weapons/v_knife_default_t.mdl")] = KnifeToModelMatrix[KnifeT].c_str();
ModelList[pModelInfo->GetModelIndex("models/weapons/v_models/arms/glove_hardknuckle/v_glove_hardknuckle.mdl")] = GloveToModelMatrix[GloveCT].c_str();
ModelList[pModelInfo->GetModelIndex("models/weapons/v_models/arms/glove_fingerless/v_glove_fingerless.mdl")] = GloveToModelMatrix[GloveT].c_str();
}
void cSkinchanger::ForceSkins() {
player_info_t player_info;
if(pEngine->GetPlayerInfo(pLocalPlayer->GetId(), &player_info)){
int* pWeapons = pLocalPlayer->GetWeapons();
C_BaseViewModel* LocalPlayerViewModel = (C_BaseViewModel*)pEntList->GetClientEntityFromHandle(pLocalPlayer->GetViewModel());
C_BaseAttributableItem* WeaponViewModel = nullptr;
if(LocalPlayerViewModel)
WeaponViewModel = (C_BaseAttributableItem*)pEntList->GetClientEntityFromHandle(LocalPlayerViewModel->GetWeapon());
C_BaseCombatWeapon* localWeapon = (C_BaseCombatWeapon*)pEntList->GetClientEntityFromHandle(pLocalPlayer->GetActiveWeapon());
if(pWeapons){
for(int i = 0; pWeapons[i]; i++){
C_BaseAttributableItem* attributableItem = (C_BaseAttributableItem*)pEntList->GetClientEntityFromHandle(pWeapons[i]);
if(attributableItem) {
short* Definition = attributableItem->GetItemDefinitionIndex();
unordered_map<int, cSkin>::iterator SkinIter = (*Definition == WEAPON_KNIFE ? (*Definition == WEAPON_KNIFE ? Skins.find(WEAPON_KNIFE) : Skins.find(WEAPON_KNIFE_T)) : Skins.find(*Definition));
if(SkinIter != Skins.end()) {
if(*attributableItem->GetOriginalOwnerXuidLow() == player_info.xuidlow && *attributableItem->GetOriginalOwnerXuidHigh() == player_info.xuidhigh){
int* model_index = attributableItem->GetModelIndex();
unordered_map<int, const char*>::iterator model_iter = ModelList.find(*model_index);
if(model_iter != ModelList.end()){
*model_index = pModelInfo->GetModelIndex(model_iter->second);
}
cSkin skin = move(SkinIter->second);
if(KnifeCT && (*Definition == WEAPON_KNIFE))
*attributableItem->GetItemDefinitionIndex() = KnifeCT;
else if(KnifeT && (*Definition == WEAPON_KNIFE_T))
*attributableItem->GetItemDefinitionIndex() = KnifeT;
if(skin.name) {
sprintf(attributableItem->GetCustomName(), "%s", skin.name);
}
*attributableItem->GetItemIDHigh() = -1;
*attributableItem->GetFallbackPaintKit() = skin.Paintkit;
*attributableItem->GetFallbackStatTrak() = skin.StatTrack;
*attributableItem->GetEntityQuality() = skin.EntityQuality;
*attributableItem->GetFallbackSeed() = skin.Seed;
*attributableItem->GetFallbackWear() = skin.Wear;
*attributableItem->GetAccountID() = player_info.xuidlow;
ApplyCustomGloves();
Init();
}
}
if (WeaponViewModel && WeaponViewModel == attributableItem) {
int* model_index = ((C_BaseEntity*)LocalPlayerViewModel)->GetModelIndex();
unordered_map<int, const char*>::iterator model_iter = ModelList.find(*model_index);
if (model_iter != ModelList.end()) {
*model_index = pModelInfo->GetModelIndex(model_iter->second);
}
}
}
}
if(LocalPlayerViewModel && localWeapon) {
int* model_index = ((C_BaseEntity*)LocalPlayerViewModel)->GetModelIndex();
unordered_map<int, const char*>::iterator model_iter = ModelList.find(*((C_BaseEntity*)localWeapon)->GetModelIndex());
if(model_iter != ModelList.end()){
*model_index = pModelInfo->GetModelIndex(model_iter->second);
}
}
}
}
}
void cSkinchanger::ApplyCustomGloves() {
C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
if (!pEntList->GetClientEntityFromHandle((void*)pLocal->GetWearables())) {
for (ClientClass* pClass = pClient->GetAllClasses(); pClass; pClass = pClass->m_pNext) {
if (pClass->m_ClassID != (int)EClassIds::CEconWearable)
continue;
int entry = (pEntList->GetHighestEntityIndex() + 1);
int serial = RandomInt(0x0, 0xFFF);
pClass->m_pCreateFn(entry, serial);
pLocal->GetWearables()[0] = entry | serial << 16;
glovesUpdated = true;
break;
}
}
player_info_t LocalPlayerInfo;
pEngine->GetPlayerInfo(pEngine->GetLocalPlayer(), &LocalPlayerInfo);
C_BaseAttributableItem* glove = (C_BaseAttributableItem*)pEntList->GetClientEntity(pLocal->GetWearables()[0] & 0xFFF);
if (!glove)
return;
int* glove_index = glove->GetModelIndex();
unordered_map<int, const char*>::iterator glove_iter = ModelList.find(*glove_index);
unordered_map<int, cSkin>::iterator Iter = (pLocal->GetTeam() == TEAM_COUNTER_TERRORIST ? Skins.find(GLOVE_CT) : Skins.find(GLOVE_T));
cSkin gloveskin = move(Iter->second);
if(glove_iter != ModelList.end())
*glove_index = pModelInfo->GetModelIndex(glove_iter->second);
if(GloveCT && pLocal->GetTeam() == TEAM_COUNTER_TERRORIST)
*glove->GetItemDefinitionIndex() = GloveCT;
if(GloveT && pLocal->GetTeam() == TEAM_TERRORIST)
*glove->GetItemDefinitionIndex() = GloveT;
*glove->GetItemIDHigh() = -1;
*glove->GetFallbackPaintKit() = gloveskin.Paintkit;
*glove->GetFallbackWear() = gloveskin.Wear;
*glove->GetAccountID() = LocalPlayerInfo.xuidlow;
if(glovesUpdated) {
glove->GetNetworkable()->PreDataUpdate(DATA_UPDATE_CREATED);
glovesUpdated = false;
}
}
void cSkinchanger::Init() {
ModelList.clear();
FindModels();
}
void cSkinchanger::FireEventClientSide(IGameEvent *event) {
if (!vars.visuals.skinc)
return;
if (!pEngine->IsInGame())
return;
if (!event || strcmp(event->GetName(), "player_death") != 0)
return;
if (!event->GetInt("attacker") || pEngine->GetPlayerForUserID(event->GetInt("attacker")) != pEngine->GetLocalPlayer())
return;
if(!strcmp(event->GetName(), "game_newmap")) {
Init();
}
//f(const auto icon_override = (event->GetString("weapon"))) event->SetString("weapon", icon_override);
}
inline const int RandomSequence1(int low, int high) {
return (rand() % (high - low + 1) + low);
}
void HSequenceProxyFn(const CRecvProxyData *pDataConst, void *pStruct, void *pOut) {
CRecvProxyData* pData = const_cast<CRecvProxyData*>(pDataConst);
C_BaseViewModel* pViewModel = (C_BaseViewModel*)pStruct;
if(!pViewModel)
return g_pSequence(pDataConst, pStruct, pOut);
C_BaseEntity* pOwner = (C_BaseEntity*)pEntList->GetClientEntityFromHandle(pViewModel->GetOwner());
if (pViewModel && pOwner) {
if (pOwner->GetIndex() == pEngine->GetLocalPlayer()) {
const model_t* knife_model = pModelInfo->GetModel(*pViewModel->GetModelIndex());
const char* model_filename = pModelInfo->GetModelName(knife_model);
int m_nSequence = (int)pData->m_Value.m_Int;
if (!strcmp(model_filename, "models/weapons/v_knife_butterfly.mdl")) {
switch (m_nSequence) {
case SEQUENCE_DEFAULT_DRAW:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_DRAW, SEQUENCE_BUTTERFLY_DRAW2);
break;
case SEQUENCE_DEFAULT_LOOKAT01:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_LOOKAT01, SEQUENCE_BUTTERFLY_LOOKAT03);
break;
default:
m_nSequence++;
}
} else if (!strcmp(model_filename, "models/weapons/v_knife_falchion_advanced.mdl")) {
switch (m_nSequence) {
case SEQUENCE_DEFAULT_IDLE2:
m_nSequence = SEQUENCE_FALCHION_IDLE1;
break;
case SEQUENCE_DEFAULT_HEAVY_MISS1:
m_nSequence = RandomSequence1(SEQUENCE_FALCHION_HEAVY_MISS1, SEQUENCE_FALCHION_HEAVY_MISS1_NOFLIP);
break;
case SEQUENCE_DEFAULT_LOOKAT01:
m_nSequence = RandomSequence1(SEQUENCE_FALCHION_LOOKAT01, SEQUENCE_FALCHION_LOOKAT02);
break;
case SEQUENCE_DEFAULT_DRAW:
case SEQUENCE_DEFAULT_IDLE1:
break;
default:
m_nSequence--;
}
} else if (!strcmp(model_filename, "models/weapons/v_knife_push.mdl")) {
switch (m_nSequence) {
case SEQUENCE_DEFAULT_IDLE2:
m_nSequence = SEQUENCE_DAGGERS_IDLE1;
break;
case SEQUENCE_DEFAULT_LIGHT_MISS1:
case SEQUENCE_DEFAULT_LIGHT_MISS2:
m_nSequence = RandomSequence1(SEQUENCE_DAGGERS_LIGHT_MISS1, SEQUENCE_DAGGERS_LIGHT_MISS5);
break;
case SEQUENCE_DEFAULT_HEAVY_MISS1:
m_nSequence = RandomSequence1(SEQUENCE_DAGGERS_HEAVY_MISS2, SEQUENCE_DAGGERS_HEAVY_MISS1);
break;
case SEQUENCE_DEFAULT_HEAVY_HIT1:
case SEQUENCE_DEFAULT_HEAVY_BACKSTAB:
case SEQUENCE_DEFAULT_LOOKAT01:
m_nSequence += 3;
break;
case SEQUENCE_DEFAULT_DRAW:
case SEQUENCE_DEFAULT_IDLE1:
break;
default:
m_nSequence += 2;
}
} else if (!strcmp(model_filename, "models/weapons/v_knife_survival_bowie.mdl")) {
switch (m_nSequence) {
case SEQUENCE_DEFAULT_DRAW:
case SEQUENCE_DEFAULT_IDLE1:
break;
case SEQUENCE_DEFAULT_IDLE2:
m_nSequence = SEQUENCE_BOWIE_IDLE1;
break;
default:
m_nSequence--;
}
} else if (!strcmp(model_filename, "models/weapons/v_knife_ursus.mdl")) {
switch (m_nSequence) {
case SEQUENCE_DEFAULT_DRAW:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_DRAW, SEQUENCE_BUTTERFLY_DRAW2);
break;
case SEQUENCE_DEFAULT_LOOKAT01:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_LOOKAT01, 14);
break;
default:
m_nSequence++;
}
} else if (!strcmp(model_filename, "models/weapons/v_knife_cord.mdl")) {
switch (m_nSequence) {
case SEQUENCE_DEFAULT_DRAW:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_DRAW, SEQUENCE_BUTTERFLY_DRAW2);
break;
case SEQUENCE_DEFAULT_LOOKAT01:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_LOOKAT01, 14);
break;
default:
m_nSequence++;
}
} else if (!strcmp(model_filename, "models/weapons/v_knife_canis.mdl")) {
switch (m_nSequence) {
case SEQUENCE_DEFAULT_DRAW:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_DRAW, SEQUENCE_BUTTERFLY_DRAW2);
break;
case SEQUENCE_DEFAULT_LOOKAT01:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_LOOKAT01, 14);
break;
default:
m_nSequence++;
}
} else if (!strcmp(model_filename, "models/weapons/v_knife_outdoor.mdl")) {
switch (m_nSequence) {
case SEQUENCE_DEFAULT_DRAW:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_DRAW, SEQUENCE_BUTTERFLY_DRAW2);
break;
case SEQUENCE_DEFAULT_LOOKAT01:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_LOOKAT01, 14);
break;
default:
m_nSequence++;
}
} else if (!strcmp(model_filename, "models/weapons/v_knife_skeleton.mdl")) {
switch (m_nSequence) {
case SEQUENCE_DEFAULT_DRAW:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_DRAW, SEQUENCE_BUTTERFLY_DRAW2);
break;
case SEQUENCE_DEFAULT_LOOKAT01:
m_nSequence = RandomSequence1(SEQUENCE_BUTTERFLY_LOOKAT01, 14);
break;
default:
m_nSequence++;
}
}else if (!strcmp(model_filename, "models/weapons/v_knife_stiletto.mdl")) {
switch (m_nSequence){
case SEQUENCE_DEFAULT_LOOKAT01:
m_nSequence = RandomSequence1(12, 13);
break;
}
} else if(!strcmp(model_filename, "models/weapons/v_knife_widowmaker.mdl")) {
switch (m_nSequence) {
case SEQUENCE_DEFAULT_LOOKAT01:
m_nSequence = RandomSequence1(SEQUENCE_TALON_LOOKAT1, SEQUENCE_TALON_LOOKAT2);
break;
}
}
pData->m_Value.m_Int = m_nSequence;
}
}
return g_pSequence(pData, pStruct, pOut);
}
| 46.486559 | 211 | 0.542879 | manigamer22 |
29ccd620f5e5f498b894af52bc4063ed5bd7623c | 1,315 | cpp | C++ | _site/PDI/Addweighted/addweighted.cpp | luccasbonato/luccasbonato.github.io | 7842e1f0eae7bc47ad5c8f07132f5073dc36ee72 | [
"MIT"
] | null | null | null | _site/PDI/Addweighted/addweighted.cpp | luccasbonato/luccasbonato.github.io | 7842e1f0eae7bc47ad5c8f07132f5073dc36ee72 | [
"MIT"
] | null | null | null | _site/PDI/Addweighted/addweighted.cpp | luccasbonato/luccasbonato.github.io | 7842e1f0eae7bc47ad5c8f07132f5073dc36ee72 | [
"MIT"
] | null | null | null | #include <iostream>
#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;
double alfa;
int alfa_slider = 0;
int alfa_slider_max = 100;
int top_slider = 0;
int top_slider_max = 100;
Mat image1, image2, blended;
Mat imageTop;
char TrackbarName[50];
void on_trackbar_blend(int, void*){
alfa = (double) alfa_slider/alfa_slider_max ;
addWeighted( image1, alfa, imageTop, 1-alfa, 0.0, blended);
imshow("addweighted", blended);
}
void on_trackbar_line(int, void*){
image1.copyTo(imageTop);
int limit = top_slider*255/100;
if(limit > 0){
Mat tmp = image2(Rect(0, 0, 256, limit));
tmp.copyTo(imageTop(Rect(0, 0, 256, limit)));
}
on_trackbar_blend(alfa_slider,0);
}
int main(int argvc, char** argv){
image1 = imread("blend1.jpg");
image2 = imread("blend2.jpg");
image2.copyTo(imageTop);
namedWindow("addweighted", 1);
sprintf( TrackbarName, "Alpha x %d", alfa_slider_max );
createTrackbar( TrackbarName, "addweighted",
&alfa_slider,
alfa_slider_max,
on_trackbar_blend );
on_trackbar_blend(alfa_slider, 0 );
sprintf( TrackbarName, "Scanline x %d", top_slider_max );
createTrackbar( TrackbarName, "addweighted",
&top_slider,
top_slider_max,
on_trackbar_line );
on_trackbar_line(top_slider, 0 );
waitKey(0);
return 0;
}
| 22.672414 | 60 | 0.698099 | luccasbonato |
29ce306266e7f60fc8586475b440bc85961e000d | 2,136 | hpp | C++ | src/multiple_request_handler.hpp | stanislav-podlesny/cpp-driver | be08fd0f6cfbf90ec98fdfbe1745e3470bdeeb1d | [
"Apache-2.0"
] | null | null | null | src/multiple_request_handler.hpp | stanislav-podlesny/cpp-driver | be08fd0f6cfbf90ec98fdfbe1745e3470bdeeb1d | [
"Apache-2.0"
] | null | null | null | src/multiple_request_handler.hpp | stanislav-podlesny/cpp-driver | be08fd0f6cfbf90ec98fdfbe1745e3470bdeeb1d | [
"Apache-2.0"
] | null | null | null | /*
Copyright (c) 2014-2015 DataStax
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 __CASS_MULTIPLE_REQUEST_HANDLER_HPP_INCLUDED__
#define __CASS_MULTIPLE_REQUEST_HANDLER_HPP_INCLUDED__
#include "handler.hpp"
#include "ref_counted.hpp"
#include "request.hpp"
#include <string>
#include <vector>
namespace cass {
class Connection;
class Response;
class MultipleRequestHandler : public RefCounted<MultipleRequestHandler> {
public:
typedef std::vector<Response*> ResponseVec;
MultipleRequestHandler(Connection* connection)
: connection_(connection)
, has_errors_or_timeouts_(false)
, remaining_(0) {}
virtual ~MultipleRequestHandler();
void execute_query(const std::string& query);
virtual void on_set(const ResponseVec& responses) = 0;
virtual void on_error(CassError code, const std::string& message) = 0;
virtual void on_timeout() = 0;
Connection* connection() {
return connection_;
}
private:
class InternalHandler : public Handler {
public:
InternalHandler(MultipleRequestHandler* parent, Request* request, int index)
: parent_(parent)
, request_(request)
, index_(index) {}
const Request* request() const {
return request_.get();
}
virtual void on_set(ResponseMessage* response);
virtual void on_error(CassError code, const std::string& message);
virtual void on_timeout();
private:
ScopedRefPtr<MultipleRequestHandler> parent_;
ScopedRefPtr<Request> request_;
int index_;
};
Connection* connection_;
bool has_errors_or_timeouts_;
int remaining_;
ResponseVec responses_;
};
} // namespace cass
#endif
| 25.428571 | 80 | 0.742509 | stanislav-podlesny |
29d20bfcfeebf0b8c8d3bb1e15e3107f9a36f476 | 3,600 | hpp | C++ | uni/model.hpp | PredatorCZ/PreCore | 98f5896e35371d034e6477dd0ce9edeb4fd8d814 | [
"Apache-2.0"
] | 5 | 2019-10-17T15:52:38.000Z | 2021-08-10T18:57:32.000Z | uni/model.hpp | PredatorCZ/PreCore | 98f5896e35371d034e6477dd0ce9edeb4fd8d814 | [
"Apache-2.0"
] | null | null | null | uni/model.hpp | PredatorCZ/PreCore | 98f5896e35371d034e6477dd0ce9edeb4fd8d814 | [
"Apache-2.0"
] | 1 | 2021-01-31T20:37:42.000Z | 2021-01-31T20:37:42.000Z | /* render model module
part of uni module
Copyright 2020-2021 Lukas Cone
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 "format.hpp"
#include "list.hpp"
namespace uni {
struct RTSValue;
struct BBOX {
Vector4A16 min;
Vector4A16 max;
};
class PrimitiveDescriptor : public Base {
public:
enum class UnpackDataType_e {
None,
Add, // x + min
Mul, // x * min
Madd, // max + x * min
};
enum class Usage_e : uint8 {
Undefined,
Position,
Normal,
Tangent,
BiTangent,
TextureCoordiante,
BoneIndices,
BoneWeights,
VertexColor,
VertexIndex,
PositionDelta,
};
// Get already indexed & offseted vertex buffer
virtual const char *RawBuffer() const = 0;
virtual size_t Stride() const = 0;
virtual size_t Offset() const = 0;
virtual size_t Index() const = 0;
virtual Usage_e Usage() const = 0;
virtual FormatDescr Type() const = 0;
virtual FormatCodec &Codec() const { return FormatCodec::Get(Type()); }
virtual BBOX UnpackData() const = 0;
virtual UnpackDataType_e UnpackDataType() const = 0;
void Resample(FormatCodec::fvec &data) const;
};
typedef Element<const List<PrimitiveDescriptor>> PrimitiveDescriptorsConst;
typedef Element<List<PrimitiveDescriptor>> PrimitiveDescriptors;
class Primitive : public Base {
public:
enum class IndexType_e { None, Line, Triangle, Strip, Fan };
virtual const char *RawIndexBuffer() const = 0;
virtual const char *RawVertexBuffer(size_t id) const = 0;
virtual PrimitiveDescriptorsConst Descriptors() const = 0;
virtual IndexType_e IndexType() const = 0;
virtual size_t IndexSize() const = 0;
virtual size_t NumVertices() const = 0;
virtual size_t NumVertexBuffers() const = 0;
virtual size_t NumIndices() const = 0;
virtual std::string Name() const = 0;
virtual size_t SkinIndex() const = 0;
virtual size_t LODIndex() const = 0;
virtual size_t MaterialIndex() const = 0;
};
typedef Element<const List<Primitive>> PrimitivesConst;
typedef Element<List<Primitive>> Primitives;
class PC_EXTERN Skin : public Base {
public:
virtual size_t NumNodes() const = 0;
virtual TransformType TMType() const = 0;
virtual void GetTM(RTSValue &out, size_t index) const;
virtual void GetTM(esMatrix44 &out, size_t index) const;
virtual size_t NodeIndex(size_t index) const = 0;
};
typedef Element<const List<Skin>> SkinsConst;
typedef Element<List<Skin>> Skins;
using ResourcesConst = Element<const List<std::string>>;
using Resources = Element<List<std::string>>;
class Material : public Base {
public:
virtual size_t Version() const = 0;
virtual std::string Name() const = 0;
virtual std::string TypeName() const = 0;
};
using MaterialsConst = Element<const List<Material>>;
using Materials = Element<List<Material>>;
class Model : public Base {
public:
virtual PrimitivesConst Primitives() const = 0;
virtual SkinsConst Skins() const = 0;
virtual ResourcesConst Resources() const = 0;
virtual MaterialsConst Materials() const = 0;
};
} // namespace uni
#include "internal/model.inl"
| 29.032258 | 76 | 0.718056 | PredatorCZ |
29d5ae84ab17692be10a1daa491dfa71a11c784e | 283 | cpp | C++ | beecrowd/C++/inciante+/1169.cpp | MateusdeNovaesSantos/Tecnologias | 0a4d55f82942e33ed86202c58596f03d0dddbf6d | [
"MIT"
] | null | null | null | beecrowd/C++/inciante+/1169.cpp | MateusdeNovaesSantos/Tecnologias | 0a4d55f82942e33ed86202c58596f03d0dddbf6d | [
"MIT"
] | null | null | null | beecrowd/C++/inciante+/1169.cpp | MateusdeNovaesSantos/Tecnologias | 0a4d55f82942e33ed86202c58596f03d0dddbf6d | [
"MIT"
] | null | null | null | #include <iostream>
#include <math.h>
using namespace std;
int main(){
long long int n = 0, x;
cin >> n;
for(int i = 0; i < n; i++){
x = 0;
cin >> x;
x = ((pow(2, x)) / 12) / 1000;
cout << x << " kg" << endl;
}
return 0;
} | 12.304348 | 38 | 0.409894 | MateusdeNovaesSantos |
29d6e3344a6ddc15ba2da49cc2066cdd5253f52f | 236 | cpp | C++ | Programmers/EvenOdd.cpp | YEAjiJUNG/AlgorithmPractice | 720abd9bb3bf1eeadf57402379fdf30921f7c333 | [
"Apache-2.0"
] | 1 | 2021-05-21T02:23:38.000Z | 2021-05-21T02:23:38.000Z | Programmers/EvenOdd.cpp | YEAjiJUNG/AlgorithmPractice | 720abd9bb3bf1eeadf57402379fdf30921f7c333 | [
"Apache-2.0"
] | null | null | null | Programmers/EvenOdd.cpp | YEAjiJUNG/AlgorithmPractice | 720abd9bb3bf1eeadf57402379fdf30921f7c333 | [
"Apache-2.0"
] | null | null | null | #include <string>
#include <vector>
using namespace std;
string solution(int num)
{
string answer = "";
if (num % 2 == 0)
{
answer = "Even";
}
else
{
answer = "Odd";
}
return answer;
} | 11.8 | 24 | 0.495763 | YEAjiJUNG |
29d7f6c1bb866a7cc6826ca59aa14a4e7e7fa624 | 8,821 | cpp | C++ | lib/IRremoteESP8266/src/ir_Xmp.cpp | Eliauk-Forever/JARVIS | 69569e530f0bc66c90bc2ba2a266edb65006bd6f | [
"MulanPSL-1.0"
] | 14 | 2019-07-09T09:38:59.000Z | 2022-02-11T13:57:18.000Z | lib/IRremoteESP8266/src/ir_Xmp.cpp | Eliauk-Forever/JARVIS | 69569e530f0bc66c90bc2ba2a266edb65006bd6f | [
"MulanPSL-1.0"
] | null | null | null | lib/IRremoteESP8266/src/ir_Xmp.cpp | Eliauk-Forever/JARVIS | 69569e530f0bc66c90bc2ba2a266edb65006bd6f | [
"MulanPSL-1.0"
] | 1 | 2021-06-26T22:26:58.000Z | 2021-06-26T22:26:58.000Z | // Copyright 2021 David Conran
/// @file
/// @brief Support for XMP protocols.
/// @see https://github.com/crankyoldgit/IRremoteESP8266/issues/1414
/// @see http://www.hifi-remote.com/wiki/index.php/XMP
// Supports:
// Brand: Xfinity, Model: XR2 remote
// Brand: Xfinity, Model: XR11 remote
#include <algorithm>
#include "IRrecv.h"
#include "IRsend.h"
#include "IRutils.h"
// Constants
const uint16_t kXmpMark = 210; ///< uSeconds.
const uint16_t kXmpBaseSpace = 760; ///< uSeconds
const uint16_t kXmpSpaceStep = 135; ///< uSeconds
const uint16_t kXmpFooterSpace = 13000; ///< uSeconds.
const uint32_t kXmpMessageGap = 80400; ///< uSeconds.
const uint8_t kXmpWordSize = kNibbleSize; ///< nr. of Bits in a word.
const uint8_t kXmpMaxWordValue = (1 << kXmpWordSize) - 1; // Max word value.
const uint8_t kXmpSections = 2; ///< Nr. of Data sections
const uint8_t kXmpRepeatCode = 0b1000;
const uint8_t kXmpRepeatCodeAlt = 0b1001;
using irutils::setBits;
namespace IRXmpUtils {
/// Get the current checksum value from an XMP data section.
/// @param[in] data The value of the data section.
/// @param[in] nbits The number of data bits in the section.
/// @return The value of the stored checksum.
/// @warning Returns 0 if we can't obtain a valid checksum.
uint8_t getSectionChecksum(const uint32_t data, const uint16_t nbits) {
// The checksum is the 2nd most significant nibble of a section.
return (nbits < 2 * kNibbleSize) ? 0 : GETBITS32(data,
nbits - (2 * kNibbleSize),
kNibbleSize);
}
/// Calculate the correct checksum value for an XMP data section.
/// @param[in] data The value of the data section.
/// @param[in] nbits The number of data bits in the section.
/// @return The value of the correct checksum.
uint8_t calcSectionChecksum(const uint32_t data, const uint16_t nbits) {
return (0xF & ~(irutils::sumNibbles(data, nbits / kNibbleSize, 0xF, false) -
getSectionChecksum(data, nbits)));
}
/// Recalculate a XMP message code ensuring it has the checksums valid.
/// @param[in] data The value of the XMP message code.
/// @param[in] nbits The number of data bits in the entire message code.
/// @return The corrected XMP message with valid checksum sections.
uint64_t updateChecksums(const uint64_t data, const uint16_t nbits) {
const uint16_t sectionbits = nbits / kXmpSections;
uint64_t result = data;
for (uint16_t sectionOffset = 0; sectionOffset < nbits;
sectionOffset += sectionbits) {
const uint16_t checksumOffset = sectionOffset + sectionbits -
(2 * kNibbleSize);
setBits(&result, checksumOffset, kNibbleSize,
calcSectionChecksum(GETBITS64(data, sectionOffset, sectionbits),
sectionbits));
}
return result;
}
/// Calculate the bit offset the repeat nibble in an XMP code.
/// @param[in] nbits The number of data bits in the entire message code.
/// @return The offset to the start of the XMP repeat nibble.
uint16_t calcRepeatOffset(const uint16_t nbits) {
return (nbits < 3 * kNibbleSize) ? 0
: (nbits / kXmpSections) -
(3 * kNibbleSize);
}
/// Test if an XMP message code is a repeat or not.
/// @param[in] data The value of the XMP message code.
/// @param[in] nbits The number of data bits in the entire message code.
/// @return true, if it looks like a repeat, false if not.
bool isRepeat(const uint64_t data, const uint16_t nbits) {
switch (GETBITS64(data, calcRepeatOffset(nbits), kNibbleSize)) {
case kXmpRepeatCode:
case kXmpRepeatCodeAlt:
return true;
default:
return false;
}
}
/// Adjust an XMP message code to make it a valid repeat or non-repeat code.
/// @param[in] data The value of the XMP message code.
/// @param[in] nbits The number of data bits in the entire message code.
/// @param[in] repeat_code The value of the XMP repeat nibble to use.
/// A value of `8` is the normal value for a repeat. `9` has also been seen.
/// A value of `0` will convert the code to a non-repeat code.
/// @return The valud of the modified XMP code.
uint64_t adjustRepeat(const uint64_t data, const uint16_t nbits,
const uint8_t repeat_code) {
uint64_t result = data;
setBits(&result, calcRepeatOffset(nbits), kNibbleSize, repeat_code);
return updateChecksums(result, nbits);
}
} // namespace IRXmpUtils
using IRXmpUtils::calcSectionChecksum;
using IRXmpUtils::getSectionChecksum;
using IRXmpUtils::isRepeat;
using IRXmpUtils::adjustRepeat;
#if SEND_XMP
/// Send a XMP packet.
/// Status: Beta / Untested against a real device.
/// @param[in] data The message to be sent.
/// @param[in] nbits The number of bits of message to be sent.
/// @param[in] repeat The number of times the command is to be repeated.
void IRsend::sendXmp(const uint64_t data, const uint16_t nbits,
const uint16_t repeat) {
enableIROut(38000);
if (nbits < 2 * kXmpWordSize) return; // Too small to send, abort!
uint64_t send_data = data;
for (uint16_t r = 0; r <= repeat; r++) {
uint16_t bits_so_far = kXmpWordSize;
for (uint64_t mask = ((uint64_t)kXmpMaxWordValue) << (nbits - kXmpWordSize);
mask;
mask >>= kXmpWordSize) {
uint8_t word = (send_data & mask) >> (nbits - bits_so_far);
mark(kXmpMark);
space(kXmpBaseSpace + word * kXmpSpaceStep);
bits_so_far += kXmpWordSize;
// Are we at a data section boundary?
if ((bits_so_far - kXmpWordSize) % (nbits / kXmpSections) == 0) { // Yes.
mark(kXmpMark);
space(kXmpFooterSpace);
}
}
space(kXmpMessageGap - kXmpFooterSpace);
// Modify the value if needed, to make it into a valid repeat code.
if (!isRepeat(send_data, nbits))
send_data = adjustRepeat(send_data, nbits, kXmpRepeatCode);
}
}
#endif // SEND_XMP
#if DECODE_XMP
/// Decode the supplied XMP packet/message.
/// Status: BETA / Probably works.
/// @param[in,out] results Ptr to the data to decode & where to store the result
/// @param[in] offset The starting index to use when attempting to decode the
/// raw data. Typically/Defaults to kStartOffset.
/// @param[in] nbits The number of data bits to expect.
/// @param[in] strict Flag indicating if we should perform strict matching.
/// @return True if it can decode it, false if it can't.
bool IRrecv::decodeXmp(decode_results *results, uint16_t offset,
const uint16_t nbits, const bool strict) {
uint64_t data = 0;
if (results->rawlen < 2 * (nbits / kXmpWordSize) + (kXmpSections * kFooter) +
offset - 1)
return false; // Not enough entries to ever be XMP.
// Compliance
if (strict && nbits != kXmpBits) return false;
// Data
// Sections
for (uint8_t section = 1; section <= kXmpSections; section++) {
for (uint16_t bits_so_far = 0; bits_so_far < nbits / kXmpSections;
bits_so_far += kXmpWordSize) {
if (!matchMarkRange(results->rawbuf[offset++], kXmpMark)) return 0;
uint8_t value = 0;
bool found = false;
for (; value <= kXmpMaxWordValue; value++) {
if (matchSpaceRange(results->rawbuf[offset],
kXmpBaseSpace + value * kXmpSpaceStep,
kXmpSpaceStep / 2, 0)) {
found = true;
break;
}
}
if (!found) return 0; // Failure.
data <<= kXmpWordSize;
data += value;
offset++;
}
// Section Footer
if (!matchMarkRange(results->rawbuf[offset++], kXmpMark)) return 0;
if (section < kXmpSections) {
if (!matchSpace(results->rawbuf[offset++], kXmpFooterSpace)) return 0;
} else { // Last section
if (offset < results->rawlen &&
!matchAtLeast(results->rawbuf[offset++], kXmpFooterSpace)) return 0;
}
}
// Compliance
if (strict) {
// Validate checksums.
uint64_t checksum_data = data;
const uint16_t section_size = nbits / kXmpSections;
// Each section has a checksum.
for (uint16_t section = 0; section < kXmpSections; section++) {
if (getSectionChecksum(checksum_data, section_size) !=
calcSectionChecksum(checksum_data, section_size))
return 0;
checksum_data >>= section_size;
}
}
// Success
results->value = data;
results->decode_type = decode_type_t::XMP;
results->bits = nbits;
results->address = 0;
results->command = 0;
// See if it is a repeat message.
results->repeat = isRepeat(data, nbits);
return true;
}
#endif // DECODE_XMP
| 38.859031 | 80 | 0.646979 | Eliauk-Forever |
29d8f9cde14d76577c238f7906bebf8615d3b011 | 889 | hpp | C++ | text/replacer/dashReplacer.hpp | TaylorP/TML | e4c0c7ce69645a1cf30df005af786a15f85b54a2 | [
"MIT"
] | 4 | 2015-12-17T21:58:27.000Z | 2019-10-31T16:50:41.000Z | text/replacer/dashReplacer.hpp | TaylorP/TML | e4c0c7ce69645a1cf30df005af786a15f85b54a2 | [
"MIT"
] | null | null | null | text/replacer/dashReplacer.hpp | TaylorP/TML | e4c0c7ce69645a1cf30df005af786a15f85b54a2 | [
"MIT"
] | 1 | 2019-05-07T18:51:00.000Z | 2019-05-07T18:51:00.000Z | #ifndef DASH_REPLACER_HPP
#define DASH_REPLACER_HPP
#include <iostream>
#include <unordered_map>
#include "text/replacer/replacer.hpp"
/// Replaces -- with an en-dash and --- with an em-dash
class DashReplacer : public Replacer
{
public:
/// Constructs a new dash replacer
DashReplacer(const ReplacerTable* pTable);
/// Replaces dashes and output html
virtual std::string replace(const char pPrev,
const char pCur,
const char pNext,
bool& pConsume);
/// Not used in this replacer
virtual ReplacerState state() const { return eStateNormal; }
/// Resets found state
virtual void reset();
//// Verifies that found dashes were emitted
virtual void verify() const;
private:
/// A dash block of atleast two was found
int mCount;
};
#endif | 24.694444 | 64 | 0.625422 | TaylorP |
29df6c736e8af36d1a3e77c9d25be4964c46a3c6 | 1,149 | cpp | C++ | 1011 - Marriage Ceremonies.cpp | BRAINIAC2677/Lightoj-Solutions | e75f56b2cb4ef8f7e00de39fed447b1b37922427 | [
"MIT"
] | null | null | null | 1011 - Marriage Ceremonies.cpp | BRAINIAC2677/Lightoj-Solutions | e75f56b2cb4ef8f7e00de39fed447b1b37922427 | [
"MIT"
] | null | null | null | 1011 - Marriage Ceremonies.cpp | BRAINIAC2677/Lightoj-Solutions | e75f56b2cb4ef8f7e00de39fed447b1b37922427 | [
"MIT"
] | null | null | null | /*BISMILLAH
THE WHITE WOLF
NO DREAM IS TOO BIG AND NO DREAMER IS TOO SMALL*/
#include<bits/stdc++.h>
using namespace std;
int priority_ind[16][16], dp[1<<16], n;
int Set(int n, int pos)
{
return n|(1<<pos);
}
bool check(int n, int pos)
{
return (bool)(n & (1<<pos));
}
int counting(int m)
{
int cou = 0;
while(m)
{
if(check(m, 0))
cou++;
m >>= 1;
}
return cou;
}
int bitmask()
{
for(int mask = 0; mask<=(1<<n)-1; mask++)
{
int x = counting(mask);
for(int j = 0; j <n; j++)
{
if(!check(mask, j))
{
dp[Set(mask, j)] = max(dp[Set(mask, j)], dp[mask] + priority_ind[x][j]);
}
}
}
return dp[(1<<n) - 1];
}
int main()
{
int tc;
cin >> tc;
for(int i = 1; i <= tc; i++)
{
cin >> n;
memset(priority_ind, 0, sizeof(priority_ind));
memset(dp, INT_MIN, sizeof(dp));
for(int a = 0; a<n; a++)
for(int b = 0; b < n; b++)
cin >> priority_ind[a][b];
printf("Case %d: %d\n", i, bitmask());
}
return 0;
}
| 17.676923 | 88 | 0.446475 | BRAINIAC2677 |
29e24762bf790bad655eb9b402a1dcdd11ee9dba | 4,553 | cpp | C++ | src/GQE/Core/assets/ImageHandler.cpp | Maarrch/gqe | 51f6ff82cbcafee97b9c245fa5bbea49e11a46da | [
"MIT"
] | 8 | 2017-04-06T13:14:27.000Z | 2022-01-20T22:25:04.000Z | src/GQE/Core/assets/ImageHandler.cpp | Maarrch/gqe | 51f6ff82cbcafee97b9c245fa5bbea49e11a46da | [
"MIT"
] | null | null | null | src/GQE/Core/assets/ImageHandler.cpp | Maarrch/gqe | 51f6ff82cbcafee97b9c245fa5bbea49e11a46da | [
"MIT"
] | 3 | 2019-11-09T09:46:38.000Z | 2021-02-25T00:32:28.000Z | /**
* Provides the ImageHandler class used by the AssetManager to manage all
* sf::Image assets for the application.
*
* @file src/GQE/Core/assets/ImageHandler.cpp
* @author Ryan Lindeman
* @date 20120428 - Initial Release
*/
#include <GQE/Core/assets/ImageHandler.hpp>
#include <GQE/Core/loggers/Log_macros.hpp>
namespace GQE
{
ImageHandler::ImageHandler() :
#if (SFML_VERSION_MAJOR < 2)
TAssetHandler<sf::Image>()
#else
TAssetHandler<sf::Texture>()
#endif
{
ILOG() << "ImageHandler::ctor()" << std::endl;
}
ImageHandler::~ImageHandler()
{
ILOG() << "ImageHandler::dtor()" << std::endl;
}
#if (SFML_VERSION_MAJOR < 2)
bool ImageHandler::LoadFromFile(const typeAssetID theAssetID, sf::Image& theAsset)
#else
bool ImageHandler::LoadFromFile(const typeAssetID theAssetID, sf::Texture& theAsset)
#endif
{
// Start with a return result of false
bool anResult = false;
// Retrieve the filename for this asset
std::string anFilename = GetFilename(theAssetID);
// Was a valid filename found? then attempt to load the asset from anFilename
if(anFilename.length() > 0)
{
// Load the asset from a file
#if (SFML_VERSION_MAJOR < 2)
anResult = theAsset.LoadFromFile(anFilename);
// Don't forget to set smoothing to false to better support tile base games
theAsset.SetSmooth(false);
#else
anResult = theAsset.loadFromFile(anFilename);
#endif
}
else
{
ELOG() << "ImageHandler::LoadFromFile(" << theAssetID
<< ") No filename provided!" << std::endl;
}
// Return anResult of true if successful, false otherwise
return anResult;
}
#if (SFML_VERSION_MAJOR < 2)
bool ImageHandler::LoadFromMemory(const typeAssetID theAssetID, sf::Image& theAsset)
#else
bool ImageHandler::LoadFromMemory(const typeAssetID theAssetID, sf::Texture& theAsset)
#endif
{
// Start with a return result of false
bool anResult = false;
// TODO: Retrieve the const char* pointer to load data from
const char* anData = NULL;
// TODO: Retrieve the size in bytes of the font to load from memory
size_t anDataSize = 0;
// Try to obtain the font from the memory location specified
if(NULL != anData && anDataSize > 0)
{
// Load the image from the memory location specified
#if (SFML_VERSION_MAJOR < 2)
anResult = theAsset.LoadFromMemory(anData, anDataSize);
// Don't forget to set smoothing to false to better support tile base games
theAsset.SetSmooth(false);
#else
anResult = theAsset.loadFromMemory(anData, anDataSize);
#endif
}
else
{
ELOG() << "ImageHandler::LoadFromMemory(" << theAssetID
<< ") Bad memory location or size!" << std::endl;
}
// Return anResult of true if successful, false otherwise
return anResult;
}
#if (SFML_VERSION_MAJOR < 2)
bool ImageHandler::LoadFromNetwork(const typeAssetID theAssetID, sf::Image& theAsset)
#else
bool ImageHandler::LoadFromNetwork(const typeAssetID theAssetID, sf::Texture& theAsset)
#endif
{
// Start with a return result of false
bool anResult = false;
// TODO: Add load from network for this asset
// Return anResult of true if successful, false otherwise
return anResult;
}
} // namespace GQE
/**
* Copyright (c) 2010-2012 Ryan Lindeman
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
| 32.992754 | 90 | 0.683505 | Maarrch |
29e69fe1c0f4ac6993525661bd7dc9c2d02c1af0 | 17,941 | cpp | C++ | SQL Database Object v2.1/Source/MMF2SDK/Extensions/V2Template32/Edittime.cpp | jimstjean/sqldb | 4bc2e49021fe4051f7b3fc1e752a171988d0cbb8 | [
"Apache-2.0"
] | null | null | null | SQL Database Object v2.1/Source/MMF2SDK/Extensions/V2Template32/Edittime.cpp | jimstjean/sqldb | 4bc2e49021fe4051f7b3fc1e752a171988d0cbb8 | [
"Apache-2.0"
] | null | null | null | SQL Database Object v2.1/Source/MMF2SDK/Extensions/V2Template32/Edittime.cpp | jimstjean/sqldb | 4bc2e49021fe4051f7b3fc1e752a171988d0cbb8 | [
"Apache-2.0"
] | null | null | null | ////////////////////////////////////////////////////////////////////////////
// SQL Database MMF Extension
// (c) 2004-2005, Jim St. Jean
//
// MAIN OBJECT EDIT ROUTINES - Source file
//
//
////////////////////////////////////////////////////////////////////////////
//
// Originally generated using FireMonkeySDK
//
// ============================================================================
//
// This file contains routines that are handled during the Edittime.
//
// Including creating, display, and setting up your object.
//
// ============================================================================
/*
Info from Tigs' Extension Tutorial Part 1:
This source file contains data and functions which are used at edit-time.
Have a look through, there are lots of handy edit-time functions, such as functions
which are called when your object is placed in the frame, etc. However, we want to
look at CreateObject(), called when the user chooses to insert your object.
The code here calls the setup dialog.
*/
#ifndef RUN_ONLY
// Common
#include "common.h"
// This variable will remain global between all instances of the object.
// JSJNOTE: Implements single shared global database today
GlobalData Global={NULL}; // We will check its nullity later
// JSJNOTE: Implements single shared global database today
// Prototype of setup procedure
BOOL CALLBACK DLLExport setupProc(HWND hDlg,uint msgType,WPARAM wParam,LPARAM lParam);
// Structure defined to pass edptr and mv into setup box
typedef struct tagSetP
{
EDITDATA _far * edpt;
mv _far * kv;
} setupParams;
// -----------------
// BmpToImg
// -----------------
// Converts an image from the resource to an image displayable under CC&C
// Not used in this template, but it is a good example on how to create
// an image.
/* JSJ REMOVED
_inline WORD BmpToImg(int bmID, npAppli idApp, short HotX = 0, short HotY = 0, short ActionX = 0, short ActionY = 0)
{
Img ifo;
WORD img;
HRSRC hs;
HGLOBAL hgBuf;
LPBYTE adBuf;
LPBITMAPINFOHEADER adBmi;
img = 0;
if ((hs = FindResource(hInstLib, MAKEINTRESOURCE(bmID), RT_BITMAP)) != NULL)
{
if ((hgBuf = LoadResource(hInstLib, hs)) != NULL)
{
if ((adBuf = (LPBYTE)LockResource(hgBuf)) != NULL)
{
adBmi = (LPBITMAPINFOHEADER)adBuf;
ifo.imgXSpot = HotX;
ifo.imgYSpot = HotY;
ifo.imgXAction = ActionX;
ifo.imgYAction = ActionY;
if (adBmi->biBitCount > 4)
RemapDib((LPBITMAPINFO)adBmi, idApp, NULL);
img = DibToImage(idApp, &ifo, adBmi);
UnlockResource(hgBuf);
}
FreeResource(hgBuf);
}
}
return img;
}
JSJ REMOVED */
// -----------------
// Initialize
// -----------------
// Where you want to do COLD-START initialization. Only called ONCE per application.
//
extern "C" int WINAPI DLLExport Initialize(mv _far *knpV, int quiet)
{
// Called when the application starts or restarts
// Global.db = NULL;
// No errors
return 0;
}
// -----------------
// Free
// -----------------
// Where you want to kill any initialized data opened in the above routine
// Called ONCE per application, just before freeing the DLL.
//
extern "C" int WINAPI DLLExport Free(mv _far *knpV)
{
// if (Global.db)
// sqldb_close(Global.db); /* close any global SQLDB db handle */
// No errors
return 0;
}
// --------------------
// UpdateEditStructure
// --------------------
// For you to update your object structure to newer versions
//
HGLOBAL WINAPI DLLExport UpdateEditStructure(mv __far *knpV, void __far * OldEdPtr)
{
// We do nothing here
return 0;
}
// -----------------
// LoadObject
// -----------------
// Routine called for each object, when the object is dropped in the frame.
// You can load data here, reserve memory etc...
// Called once per different object, just after loading extension data
int WINAPI DLLExport LoadObject(mv _far *knpV, LPCSTR fileName, LPEDATA edPtr, int reserved)
{
return 0;
}
// -----------------
// UnloadObject
// -----------------
// The counterpart of the above routine: called just before the object is
// deleted from the frame
void WINAPI DLLExport UnloadObject(mv _far *knpV, LPEDATA edPtr, int reserved)
{
}
// --------------------
// UpdateFileNames
// --------------------
// If you store file names in your datazone, they have to be relocated when the
// application is moved: this routine does it.
//
void WINAPI DLLExport UpdateFileNames(mv _far *knpV, LPSTR gameName, LPEDATA edPtr, void (WINAPI * lpfnUpdate)(LPSTR, LPSTR))
{
}
// --------------------
// PutObject
// --------------------
// Called when each individual object is dropped in the frame.
//
void WINAPI DLLExport PutObject(mv _far *knpV, fpLevObj loPtr, LPEDATA edPtr, ushort cpt)
{
}
// --------------------
// RemoveObject
// --------------------
// Called when each individual object is removed in the frame.
//
void WINAPI DLLExport RemoveObject(mv _far *knpV, fpLevObj loPtr, LPEDATA edPtr, ushort cpt)
{
// Is the last object removed?
if (0 == cpt)
{
// Do whatever necessary to remove our data
}
}
// --------------------
// MakeIcon
// --------------------
// Called once object is created or modified, just after setup.
//
int WINAPI DLLExport MakeIcon ( mv _far *knpV, BITMAPINFO FAR *lpBitmap, LPSTR lpName, fpObjInfo oiPtr, LPEDATA edPtr )
{
int error = -1;
ushort pSize, bSize;
HRSRC hs;
HGLOBAL hgBuf;
LPBYTE adBuf;
LPBITMAPINFOHEADER adBmi;
// Here, we simply load the icon from the resource and convert it into a format understood by CC&C.
// You could also generate the icon yourself from what the user has entered in the setup.
if ((hs = FindResource(hInstLib, MAKEINTRESOURCE(EXO_ICON), RT_BITMAP)) != NULL)
{
if ((hgBuf = LoadResource(hInstLib, hs)) != NULL)
{
if ((adBuf = (LPBYTE)LockResource(hgBuf)) != NULL)
{
adBmi = (LPBITMAPINFOHEADER)adBuf;
pSize = (adBmi->biBitCount > 8) ? 0 : (4 << (BYTE) adBmi->biBitCount);
bSize = (((WORD)adBmi->biWidth * adBmi->biBitCount + 31) &~ 31) / 8 * (WORD)adBmi->biHeight;
_fmemcpy(lpBitmap, adBuf, sizeof(BITMAPINFOHEADER) + pSize + bSize);
error = FALSE;
UnlockResource (hgBuf);
}
FreeResource(hgBuf);
}
}
return error;
}
// --------------------
// AppendPopup
// --------------------
// Called just before opening the popup menu of the object under the editor.
// You can remove or add options to the default menu...
void WINAPI DLLExport AppendPopup(mv _far *knpV, HMENU hPopup, fpLevObj loPtr, LPEDATA edPtr, int nbSel)
{
}
// --------------------
// CreateObject
// --------------------
// Called when you choose "Create new object". It should display the setup box
// and initialize everything in the datazone.
int WINAPI DLLExport CreateObject(mv _far *knpV, fpLevObj loPtr, LPEDATA edPtr)
{
// Check compatibility
if ( !IS_COMPATIBLE(knpV) )
return -1;
setupParams spa;
// Set default object flags
edPtr->sx = 0;
edPtr->sy = 0;
edPtr->swidth = 32;
edPtr->sheight = 32;
// Call setup (remove this and return 0 if your object does not need a setup)
spa.edpt = edPtr;
spa.kv = knpV;
return ((int) DialOpen(hInstLib, MAKEINTRESOURCE(DB_SETUP), knpV->mvHEditWin, setupProc, 0, 0, DL_MODAL|DL_CENTER_WINDOW, (LPARAM)(LPBYTE)&spa));
}
// --------------------
// SelectPopup
// --------------------
// One of the option from the menu has been selected, and not a default menu option
// automatically handled by CC&C: this routine is then called.
//
int WINAPI DLLExport SelectPopup(mv _far *knpV, int modif, fpObjInfo oiPtr, fpLevObj loPtr, LPEDATA edPtr, fpushort lpParams, int maxParams)
{
// Check compatibility
if ( !IS_COMPATIBLE(knpV) )
return 0;
setupParams spa;
// Remove this if your object does not need a setup
if (modif == ID_POP_SETUP)
{
spa.edpt = edPtr;
spa.kv = knpV;
if (0 == DialOpen(hInstLib, MAKEINTRESOURCE(DB_SETUP), knpV->mvHEditWin, setupProc, 0, 0, DL_MODAL | DL_CENTER_WINDOW, (LPARAM)(LPBYTE)&spa))
return MODIF_HFRAN;
}
/* if your object can be resized, remove the remark!
if (MODIF_SIZE == modif)
{
edPtr->swidth = lpParams[2];
edPtr->sheight = lpParams[3];
}
*/
return 0;
}
// --------------------
// SetupProc
// --------------------
// This routine is yours. You may even not need a setup dialog box.
// I have put it as an example...
BOOL CALLBACK DLLExport setupProc(HWND hDlg,uint msgType,WPARAM wParam,LPARAM lParam)
{
setupParams _far * spa;
EDITDATA _far * edPtr;
switch (msgType)
{
case WM_INITDIALOG: // Init dialog
SetWindowLong(hDlg, DWL_USER, lParam);
spa = (setupParams far *)lParam;
edPtr = spa->edpt;
/*
Insert your code to initalise the dialog!
Try the following code snippets:
** Change an editbox's text:
SetDlgItemText(hDlg, IDC_YOUR_EDITBOX_ID, edPtr->YourTextVariable);
** (Un)check a checkbox:
CheckDlgButton(hDlg, IDC_YOUR_CHECKBOX_ID,
edPtr->YourBooleanValue ? BST_CHECKED : BST_UNCHECKED);
** If the variable is not of type 'bool' then include a comparison
** before the question mark (conditional operator):
CheckDlgButton(hDlg, IDC_YOUR_CHECKBOX_ID,
edPtr->YourLongValue == 1 ? BST_CHECKED : BST_UNCHECKED);
** Check a radio button, deselecting the others at the same time
CheckRadioButton(hDlg, IDC_FIRST_RADIO_IN_GROUP, IDC_LAST_RADIO_IN_GROUP, IDC_RADIO_TO_CHECK);
** You should know how to add radio buttons properly in MSVC++'s dialog editor first...
** Make sure to add radiobuttons in order, and use the 'Group' property to signal a new group
** of radio buttons.
** Disable a control. Replace 'FALSE' with 'TRUE' to enable the control:
EnableWindow(GetDlgItem(hDlg, IDC_YOUR_CONTROL_ID), FALSE);
*/
return TRUE;
case WM_COMMAND: // Command
spa = (setupParams far *)GetWindowLong(hDlg, DWL_USER);
edPtr = spa->edpt;
switch (wmCommandID)
{
case IDOK:
/*
The user has pressed OK! Save our data with the following commands:
** Get text from an editbox. There is a limit to how much you can retrieve,
** make sure this limit is reasonable and your variable can hold this data.
** (Replace 'MAXIMUM_TEXT_LENGTH' with a value or defined constant!)
GetDlgItemText(hDlg, IDC_YOUR_EDITBOX_ID, edPtr->YourTextVariable, MAXIMUM_TEXT_LENGTH);
** Check if a checkbox or radiobutton is checked. This is the basic code:
(IsDlgButtonChecked(hDlg, IDC_YOUR_CHECKBOX_ID)==BST_CHECKED)
** This will return true if checked, false if not.
** If your variable is a bool, set it to this code
** If not, use an if statement or the conditional operator
if (IsDlgButtonChecked(hDlg, IDC_YOUR_CHECKBOX_ID)==BST_CHECKED)
edPtr->YourLongValue = 100;
else
edPtr->YourLongValue = 50;
*/
// Close the dialog
EndDialog(hDlg, 0);
return 0;
case IDCANCEL:
// User pressed cancel, don't save anything
// Close the dialog
EndDialog(hDlg, -1);
return 0;
case ID_HELP:
{
/* This code will run if the Help button is clicked.
If you have just a text file, try this:
(Paths relative to MMFusion.exe, don't forget to escape the backslashes!)
ShellExecute(NULL, "open", "notepad",
"Docs\\My Extension\\ThisIsMyDocumentation.txt",
NULL, SW_MAXIMIZE);
If you have a document for which the program you use can be different
(for example, an HTML document or .doc) then try this form:
ShellExecute(NULL, "open", "Docs\\My Extension\\MyDocs.html",
NULL, NULL, SW_MAXIMIZE);
If you use the ShellExecute function you must include the library
'shell32.lib' in your Release_Small config. To do this, go to menu
Project > Settings, choose 'Win32 Release_Small' on the upper-left,
click the 'Link' tab on the right and enter "shell32.lib" (w/o quotes)
at the end of the 'Object/library modules' editbox. Ensure there is a
space between this and the rest of the line. If you don't do this, you
will get 'unresolved external' errors because the compiler cannot find
the function when it links the different .cpp files together.
*/
ShellExecute(NULL, "open", "Help\\SQLDB\\SQLDB.htm",
NULL, NULL, SW_MAXIMIZE);
/* This is useful if your extension is documented in the MMF help file...
// (In other words, you'll never need it, but it was SDK's default action)
NPSTR chTmp;
if ((chTmp = (NPSTR)LocalAlloc(LPTR, _MAX_PATH)) != NULL)
{
GetModuleFileName(hInstLib, chTmp, _MAX_PATH);
spa->kv->mvKncHelp(chTmp, HELP_CONTEXT, 1);
LocalFree((HLOCAL)chTmp);
}
*/
}
return 0;
/*
If you have a button or checkbox which, when clicked, will change
something on the dialog, add them like so:
case IDC_YOUR_CLICKED_CONTROL:
// your code here
return 0;
You can use any of the commands added previously, (including the Help code,)
but it's a good idea NOT to save data to edPtr until the user presses OK.
*/
default:
break;
}
break;
default:
break;
}
return FALSE;
}
// --------------------
// ModifyObject
// --------------------
// Called by CC&C when the object has been modified
//
int WINAPI DLLExport ModifyObject(mv _far *knpV, LPEDATA edPtr, fpObjInfo oiPtr, fpLevObj loPtr, int modif, fpushort lpParams)
{
// Modification in size?
if (MODIF_SIZE == modif)
{
edPtr->swidth = lpParams[2];
edPtr->sheight = lpParams[3];
}
// No errors...
return 0;
}
// --------------------
// RebuildExt
// --------------------
// This routine rebuilds the new extension datazone from the old one, and the
// modifications done in the setup dialog
int WINAPI DLLExport RebuildExt(mv _far *knpV, LPEDATA edPtr, LPBYTE oldExtPtr, fpObjInfo oiPtr, fpLevObj loPtr, fpushort lpParams)
{
// No errors
return 0;
}
// --------------------
// EndModifyObject
// --------------------
// After all modifications are done, this routine is called.
// You can free any memory allocated here.
void WINAPI DLLExport EndModifyObject(mv _far *knpV, int modif, fpushort lpParams)
{
}
// --------------------
// GetObjectRect
// --------------------
// Returns the size of the rectangle of the object in the frame window
//
void WINAPI DLLExport GetObjectRect(mv _far *knpV, RECT FAR *rc, fpLevObj loPtr, LPEDATA edPtr)
{
//Print("GetObjectRect");
rc->right = rc->left + edPtr->swidth;
rc->bottom = rc->top + edPtr->sheight;
return;
}
// --------------------
// EditorDisplay
// --------------------
// Displays the object under the frame editor
//
void WINAPI DLLExport EditorDisplay(mv _far *knpV, fpObjInfo oiPtr, fpLevObj loPtr, LPEDATA edPtr, RECT FAR *rc)
{
/* This is a simple case of drawing an image onto MMF's frame editor window
First, we must get a pointer to the surface used by the frame editor
*/
LPSURFACE ps = WinGetSurface((int)knpV->mvIdEditWin);
if ( ps != NULL ) // Do the following if this surface exists
{
int x = rc->left; // get our boundaries
int y = rc->top;
int w = rc->right-rc->left;
int h = rc->bottom-rc->top;
cSurface is; // New surface variable for us to use
is.Create(4, 4, ps); // Create a surface implementation from a prototype (frame editor win)
is.LoadImage(hInstLib, EXO_IMAGE, LI_REMAP); // Load our bitmap from the resource,
// and remap palette if necessary
is.Blit(*ps, x, y, BMODE_TRANSP, BOP_COPY, 0); // Blit the image to the frame editor surface!
// This actually blits (or copies) the whole of our surface onto the frame editor's surface
// at a specified position.
// We could use different image effects when we copy, e.g. invert, AND, OR, XOR,
// blend (semi-transparent, the 6th param is amount of transparency)
// You can 'anti-alias' with the 7th param (default=0 or off)
}
}
// --------------------
// IsTransparent
// --------------------
// This routine tells CC&C if the mouse pointer is over a transparent zone of the object.
//
extern "C" {
BOOL WINAPI DLLExport IsTransparent(mv _far *knpV, fpLevObj loPtr, LPEDATA edPtr, int dx, int dy)
{
return FALSE;
}
}
// --------------------
// PrepareToWriteObject
// --------------------
// Just before writing the datazone when saving the application, CC&C calls this routine.
//
void WINAPI DLLExport PrepareToWriteObject(mv _far *knpV, LPEDATA edPtr, fpObjInfo adoi)
{
}
// --------------------
// UsesFile
// --------------------
// Triggers when a file is dropped onto the frame
BOOL WINAPI DLLExport UsesFile (LPMV mV, LPSTR fileName)
{
// Return TRUE if you can create an object from the given file
return FALSE;
// Example: return TRUE if file extension is ".txt"
/* BOOL r = FALSE;
NPSTR ext, npath;
if ( fileName != NULL )
{
if ( (ext=(NPSTR)LocalAlloc(LPTR, _MAX_EXT)) != NULL )
{
if ( (npath=(NPSTR)LocalAlloc(LPTR, _MAX_PATH)) != NULL )
{
_fstrcpy(npath, fileName);
_splitpath(npath, NULL, NULL, NULL, ext);
if ( _stricmp(ext, ".txt") == 0 )
r = TRUE;
LocalFree((HLOCAL)npath);
}
LocalFree((HLOCAL)ext);
}
}
return r; */
}
// --------------------
// CreateFromFile
// --------------------
// Creates a new object from file
void WINAPI DLLExport CreateFromFile (LPMV mV, LPSTR fileName, LPEDATA edPtr)
{
// Initialize your extension data from the given file
edPtr->swidth = 32;
edPtr->sheight = 32;
// Example: store the filename
// _fstrcpy(edPtr->myFileName, fileName);
}
// ---------------------
// EnumElts
// ---------------------
int WINAPI DLLExport EnumElts (mv __far *knpV, LPEDATA edPtr, ENUMELTPROC enumProc, ENUMELTPROC undoProc, LPARAM lp1, LPARAM lp2)
{
int error = 0;
/*
//Uncomment this if you need to store an image in the image bank.
//Replace imgidx with the variable you create within the edit structure
// Enum images
if ( (error = enumProc(&edPtr->imgidx, IMG_TAB, lp1, lp2)) != 0 )
{
// Undo enum images
undoProc (&edPtr->imgidx, IMG_TAB, lp1, lp2);
}
*/
return error;
}
#endif //Not RUN_ONLY | 28.7056 | 146 | 0.645449 | jimstjean |
29ecdb3ac25c9790a907d98417f5d5ef6c9fc9f8 | 1,175 | hpp | C++ | SparCraft/source/UnitType.hpp | iali17/TheDon | f21cae2357835e7a21ebf351abb6bb175f67540c | [
"MIT"
] | null | null | null | SparCraft/source/UnitType.hpp | iali17/TheDon | f21cae2357835e7a21ebf351abb6bb175f67540c | [
"MIT"
] | null | null | null | SparCraft/source/UnitType.hpp | iali17/TheDon | f21cae2357835e7a21ebf351abb6bb175f67540c | [
"MIT"
] | null | null | null | #pragma once
#include "Location.hpp"
class Unit
{
int _damage,
_maxHP,
_currentHP,
_range,
_moveCooldown,
_weaponCooldown,
_lastMove,
_lastAttack;
public:
Unit()
: _damage(0)
, _maxHP(0)
, _currentHP(0)
, _range(0)
, _moveCooldown(0)
, _weaponCooldown(0)
, _lastMove(-1)
, _lastAttack(-1)
{
}
Unit(const int & damage, const int & maxHP, const int & currentHP,
const int & range, const int & moveCooldown, const int & weaponCooldown)
: _damage(damage)
, _maxHP(maxHP)
, _currentHP(currentHP)
, _range(range)
, _moveCooldown(moveCooldown)
, _weaponCooldown(weaponCooldown)
, _lastMove(-1)
, _lastAttack(-1)
{
}
const int damage() const { return _damage; }
const int maxHP() const { return _maxHP; }
const int currentHP() const { return _currentHP; }
const int range() const { return _range; }
const int moveCooldown() const { return _moveCooldown; }
const int weaponCooldown() const { return _weaponCooldown; }
const int lastMove() const { return _lastMove; }
const int lastAttack() const { return _lastAttack; }
};
| 21.759259 | 77 | 0.63234 | iali17 |
29ee3fe522680b401181284cfe77cc6acca2185a | 13,683 | cpp | C++ | munin/src/scroll_pane.cpp | KazDragon/paradice9 | bb89ce8bff2f99d2526f45b064bfdd3412feb992 | [
"MIT"
] | 9 | 2015-12-16T07:00:39.000Z | 2021-05-05T13:29:28.000Z | munin/src/scroll_pane.cpp | KazDragon/paradice9 | bb89ce8bff2f99d2526f45b064bfdd3412feb992 | [
"MIT"
] | 43 | 2015-07-18T11:13:15.000Z | 2017-07-15T13:18:43.000Z | munin/src/scroll_pane.cpp | KazDragon/paradice9 | bb89ce8bff2f99d2526f45b064bfdd3412feb992 | [
"MIT"
] | 3 | 2015-10-09T13:33:35.000Z | 2016-07-11T02:23:08.000Z | // ==========================================================================
// Munin Scroll Pane
//
// Copyright (C) 2011 Matthew Chaplain, All Rights Reserved.
//
// Permission to reproduce, distribute, perform, display, and to prepare
// derivitive works from this file under the following conditions:
//
// 1. Any copy, reproduction or derivitive work of any part of this file
// contains this copyright notice and licence in its entirety.
//
// 2. The rights granted to you under this license automatically terminate
// should you attempt to assert any patent claims against the licensor
// or contributors, which in any way restrict the ability of any party
// from using this software or portions thereof in any form under the
// terms of this license.
//
// Disclaimer: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
// KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
// OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// ==========================================================================
#include "munin/scroll_pane.hpp"
#include "munin/basic_frame.hpp"
#include "munin/container.hpp"
#include "munin/horizontal_scroll_bar.hpp"
#include "munin/filled_box.hpp"
#include "munin/framed_component.hpp"
#include "munin/grid_layout.hpp"
#include "munin/unicode_glyphs.hpp"
#include "munin/vertical_scroll_bar.hpp"
#include "munin/viewport.hpp"
#include "terminalpp/element.hpp"
#include <algorithm>
namespace munin {
namespace {
class scroll_frame : public basic_frame
{
public :
// ======================================================================
// CONSTRUCTOR
// ======================================================================
scroll_frame(
std::shared_ptr<horizontal_scroll_bar> const &hscroll_bar,
std::shared_ptr<vertical_scroll_bar> const &vscroll_bar,
bool top_border)
: basic_frame(
top_border
? make_fill(single_lined_rounded_top_left_corner)
: std::shared_ptr<filled_box>(),
top_border
? make_fill(single_lined_horizontal_beam)
: std::shared_ptr<filled_box>(),
top_border
? make_fill(single_lined_rounded_top_right_corner)
: std::shared_ptr<filled_box>(),
make_fill(single_lined_vertical_beam),
vscroll_bar,
make_fill(single_lined_rounded_bottom_left_corner),
hscroll_bar,
make_fill(single_lined_rounded_bottom_right_corner))
{
}
// ======================================================================
// DESTRUCTOR
// ======================================================================
~scroll_frame()
{
}
};
}
// ==========================================================================
// SCROLL_PANE::IMPLEMENTATION STRUCTURE
// ==========================================================================
struct scroll_pane::impl
{
// ======================================================================
// CONSTRUCTOR
// ======================================================================
impl(scroll_pane &self)
: self_(self)
{
}
scroll_pane &self_;
std::shared_ptr<component> underlying_component_;
std::shared_ptr<viewport> viewport_;
std::shared_ptr<horizontal_scroll_bar> horizontal_scroll_bar_;
std::shared_ptr<vertical_scroll_bar> vertical_scroll_bar_;
std::shared_ptr<scroll_frame> scroll_frame_;
// ======================================================================
// ON_PAGE_LEFT
// ======================================================================
void on_page_left()
{
terminalpp::point new_origin;
auto origin = viewport_->get_origin();
new_origin = origin;
// TODO: Tab a page, not a line.
if (new_origin.x != 0)
{
--new_origin.x;
}
viewport_->set_origin(new_origin);
calculate_scrollbars();
}
// ======================================================================
// ON_PAGE_RIGHT
// ======================================================================
void on_page_right()
{
terminalpp::point new_origin;
auto origin = viewport_->get_origin();
auto size = self_.get_size();
auto underlying_component_size = underlying_component_->get_size();
// Find out how far over to the right the maximum origin should be.
// If the underlying component has a width smaller than this, then
// the max is 0, because we can't scroll to the right. Otherwise,
// it is the width of the underlying component - the width of the
// viewport.
auto max_right =
(underlying_component_size.width < size.width
? 0
: underlying_component_size.width - size.width);
// Same for the bottom, with height.
auto max_bottom =
(underlying_component_size.height < size.height
? 0
: underlying_component_size.height - size.height);
// Now, move the origin over to the right by one page, up to the
// maximum to the right.
// new_origin.x = (min)(origin.x + size.width, max_right);
new_origin.x = (std::min)(origin.x + 1, max_right);
new_origin.y = (std::min)(origin.y, max_bottom);
viewport_->set_origin(new_origin);
calculate_scrollbars();
}
// ======================================================================
// ON_PAGE_UP
// ======================================================================
void on_page_up()
{
auto origin = viewport_->get_origin();
auto size = viewport_->get_size();
// If we would tab over the top of the viewport, then move to the
// top instead.
if (size.height >= origin.y)
{
origin.y = 0;
}
// Otherwise, move up by a page.
else
{
origin.y -= size.height;
}
viewport_->set_origin(origin);
}
// ======================================================================
// ON_PAGE_DOWN
// ======================================================================
void on_page_down()
{
terminalpp::point new_origin;
auto origin = viewport_->get_origin();
auto size = viewport_->get_size();
auto underlying_component_size = underlying_component_->get_size();
// Find out how far over to the right the maximum origin should be.
// If the underlying component has a width smaller than this, then
// the max is 0, because we can't scroll to the right. Otherwise,
// it is the width of the underlying component - the width of the
// viewport.
auto max_right =
(underlying_component_size.width < size.width
? 0
: underlying_component_size.width - size.width);
// Same for the bottom, with height.
auto max_bottom =
(underlying_component_size.height < size.height
? 0
: underlying_component_size.height - size.height);
// Now, move the origin over to the right by one page, up to the
// maximum to the right.
new_origin.x = (std::min)(origin.x, max_right);
new_origin.y = (std::min)(origin.y + size.height, max_bottom);
viewport_->set_origin(new_origin);
}
// ======================================================================
// CALCULATE_HORIZONTAL_SCROLLBAR
// ======================================================================
boost::optional<odin::u8> calculate_horizontal_scrollbar()
{
auto origin = viewport_->get_origin();
auto size = viewport_->get_size();
auto underlying_component_size = underlying_component_->get_size();
odin::u8 slider_position = 0;
if (underlying_component_size.width <= size.width)
{
return {};
}
if (origin.x != 0)
{
auto max_right = underlying_component_size.width - size.width;
if (origin.x == max_right)
{
slider_position = 100;
}
else
{
slider_position = odin::u8((origin.x * 100) / max_right);
if (slider_position == 0)
{
slider_position = 1;
}
if (slider_position == 100)
{
slider_position = 99;
}
}
}
return slider_position;
}
// ======================================================================
// CALCULATE_VERTICAL_SCROLLBAR
// ======================================================================
boost::optional<odin::u8> calculate_vertical_scrollbar()
{
auto origin = viewport_->get_origin();
auto size = viewport_->get_size();
auto underlying_component_size = underlying_component_->get_size();
odin::u8 slider_position = 0;
if (underlying_component_size.height <= size.height)
{
return {};
}
if (origin.y != 0)
{
auto max_bottom = underlying_component_size.height - size.height;
if (origin.y == max_bottom)
{
slider_position = 100;
}
else
{
slider_position = odin::u8((origin.y * 100) / max_bottom);
if (slider_position == 0)
{
slider_position = 1;
}
if (slider_position == 100)
{
slider_position = 99;
}
}
}
return slider_position;
}
// ======================================================================
// CALCULATE_SCROLLBARS
// ======================================================================
void calculate_scrollbars()
{
// Fix the scrollbars to be at the correct percentages.
auto horizontal_slider_position = calculate_horizontal_scrollbar();
auto vertical_slider_position = calculate_vertical_scrollbar();
horizontal_scroll_bar_->set_slider_position(horizontal_slider_position);
vertical_scroll_bar_->set_slider_position(vertical_slider_position);
}
};
// ==========================================================================
// CONSTRUCTOR
// ==========================================================================
scroll_pane::scroll_pane(
std::shared_ptr<component> const &underlying_component
, bool top_border)
{
pimpl_ = std::make_shared<impl>(std::ref(*this));
pimpl_->underlying_component_ = underlying_component;
pimpl_->viewport_ = make_viewport(pimpl_->underlying_component_);
pimpl_->viewport_->on_size_changed.connect(
[this]{pimpl_->calculate_scrollbars();});
pimpl_->viewport_->on_subcomponent_size_changed.connect(
[this]{pimpl_->calculate_scrollbars();});
pimpl_->viewport_->on_origin_changed.connect(
[this]{pimpl_->calculate_scrollbars();});
pimpl_->horizontal_scroll_bar_ = make_horizontal_scroll_bar();
pimpl_->horizontal_scroll_bar_->on_page_left.connect(
[this]{pimpl_->on_page_left();});
pimpl_->horizontal_scroll_bar_->on_page_right.connect(
[this]{pimpl_->on_page_right();});
pimpl_->vertical_scroll_bar_ = make_vertical_scroll_bar();
pimpl_->vertical_scroll_bar_->on_page_up.connect(
[this]{pimpl_->on_page_up();});
pimpl_->vertical_scroll_bar_->on_page_down.connect(
[this]{pimpl_->on_page_down();});
pimpl_->scroll_frame_ = std::make_shared<scroll_frame>(
pimpl_->horizontal_scroll_bar_
, pimpl_->vertical_scroll_bar_
, top_border);
auto content = get_container();
content->set_layout(make_grid_layout(1, 1));
content->add_component(make_framed_component(
pimpl_->scroll_frame_
, pimpl_->viewport_));
}
// ==========================================================================
// DESTRUCTOR
// ==========================================================================
scroll_pane::~scroll_pane()
{
}
// ==========================================================================
// MAKE_SCROLL_PANE
// ==========================================================================
std::shared_ptr<component> make_scroll_pane(
std::shared_ptr<component> const &underlying_component,
bool top_border)
{
return std::make_shared<scroll_pane>(underlying_component, top_border);
}
}
| 36.29443 | 81 | 0.493021 | KazDragon |
29ef4bd2afea7bfd40a51de4d0e9fe0edaa46440 | 13,417 | cpp | C++ | ProcessLib/Output/Output.cpp | zhangning737/ogs | 53a892f4ce2f133e4d00534d33ad4329e5c0ccb2 | [
"BSD-4-Clause"
] | 1 | 2021-06-25T13:43:06.000Z | 2021-06-25T13:43:06.000Z | ProcessLib/Output/Output.cpp | kosakowski/OGS6-MP-LT-Drum | 01d8ef8839e5dbe50d09621393cb137d278eeb7e | [
"BSD-4-Clause"
] | 1 | 2019-08-09T12:13:22.000Z | 2019-08-09T12:13:22.000Z | ProcessLib/Output/Output.cpp | zhangning737/ogs | 53a892f4ce2f133e4d00534d33ad4329e5c0ccb2 | [
"BSD-4-Clause"
] | null | null | null | /**
* \file
* \copyright
* Copyright (c) 2012-2019, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*
*/
#include "Output.h"
#include <cassert>
#include <fstream>
#include <vector>
#include <logog/include/logog.hpp>
#include "Applications/InSituLib/Adaptor.h"
#include "BaseLib/FileTools.h"
#include "BaseLib/RunTime.h"
#include "ProcessLib/Process.h"
namespace
{
//! Converts a vtkXMLWriter's data mode string to an int. See
/// Output::_output_file_data_mode.
int convertVtkDataMode(std::string const& data_mode)
{
if (data_mode == "Ascii")
{
return 0;
}
if (data_mode == "Binary")
{
return 1;
}
if (data_mode == "Appended")
{
return 2;
}
OGS_FATAL(
"Unsupported vtk output file data mode '%s'. Expected Ascii, "
"Binary, or Appended.",
data_mode.c_str());
}
std::string constructFileName(std::string const& prefix,
int const process_id,
int const timestep,
double const t)
{
return prefix + "_pcs_" + std::to_string(process_id) + "_ts_" +
std::to_string(timestep) + "_t_" + std::to_string(t);
}
} // namespace
namespace ProcessLib
{
bool Output::shallDoOutput(int timestep, double const t)
{
int each_steps = 1;
for (auto const& pair : _repeats_each_steps)
{
each_steps = pair.each_steps;
if (timestep > pair.repeat * each_steps)
{
timestep -= pair.repeat * each_steps;
}
else
{
break;
}
}
bool make_output = timestep % each_steps == 0;
if (_fixed_output_times.empty())
{
return make_output;
}
const double specific_time = _fixed_output_times.back();
const double zero_threshold = std::numeric_limits<double>::min();
if (std::fabs(specific_time - t) < zero_threshold)
{
_fixed_output_times.pop_back();
make_output = true;
}
return make_output;
}
Output::Output(std::string output_directory, std::string output_file_prefix,
bool const compress_output, std::string const& data_mode,
bool const output_nonlinear_iteration_results,
std::vector<PairRepeatEachSteps> repeats_each_steps,
std::vector<double>&& fixed_output_times,
ProcessOutput&& process_output,
std::vector<std::string>&& mesh_names_for_output,
std::vector<std::unique_ptr<MeshLib::Mesh>> const& meshes)
: _output_directory(std::move(output_directory)),
_output_file_prefix(std::move(output_file_prefix)),
_output_file_compression(compress_output),
_output_file_data_mode(convertVtkDataMode(data_mode)),
_output_nonlinear_iteration_results(output_nonlinear_iteration_results),
_repeats_each_steps(std::move(repeats_each_steps)),
_fixed_output_times(std::move(fixed_output_times)),
_process_output(std::move(process_output)),
_mesh_names_for_output(mesh_names_for_output),
_meshes(meshes)
{
}
void Output::addProcess(ProcessLib::Process const& process,
const int process_id)
{
auto const filename = BaseLib::joinPaths(
_output_directory,
_output_file_prefix + "_pcs_" + std::to_string(process_id) + ".pvd");
_process_to_process_data.emplace(std::piecewise_construct,
std::forward_as_tuple(&process),
std::forward_as_tuple(filename));
}
// TODO return a reference.
Output::ProcessData* Output::findProcessData(Process const& process,
const int process_id)
{
auto range = _process_to_process_data.equal_range(&process);
int counter = 0;
ProcessData* process_data = nullptr;
for (auto spd_it = range.first; spd_it != range.second; ++spd_it)
{
if (counter == process_id)
{
process_data = &spd_it->second;
break;
}
counter++;
}
if (process_data == nullptr)
{
OGS_FATAL(
"The given process is not contained in the output"
" configuration. Aborting.");
}
return process_data;
}
struct Output::OutputFile
{
OutputFile(std::string const& directory, std::string const& prefix,
int const process_id, int const timestep, double const t,
int const data_mode_, bool const compression_)
: name(constructFileName(prefix, process_id, timestep, t) + ".vtu"),
path(BaseLib::joinPaths(directory, name)),
data_mode(data_mode_),
compression(compression_)
{
}
std::string const name;
std::string const path;
//! Chooses vtk's data mode for output following the enumeration given
/// in the vtkXMLWriter: {Ascii, Binary, Appended}. See vtkXMLWriter
/// documentation
/// http://www.vtk.org/doc/nightly/html/classvtkXMLWriter.html
int const data_mode;
//! Enables or disables zlib-compression of the output files.
bool const compression;
};
void Output::outputBulkMesh(OutputFile const& output_file,
ProcessData* const process_data,
MeshLib::Mesh const& mesh,
double const t) const
{
DBUG("output to %s", output_file.path.c_str());
process_data->pvd_file.addVTUFile(output_file.name, t);
makeOutput(output_file.path, mesh, output_file.compression,
output_file.data_mode);
}
void Output::doOutputAlways(Process const& process,
const int process_id,
const int timestep,
const double t,
std::vector<GlobalVector*> const& x)
{
BaseLib::RunTime time_output;
time_output.start();
std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
dof_tables.reserve(x.size());
for (std::size_t i = 0; i < x.size(); ++i)
{
dof_tables.push_back(&process.getDOFTable(i));
}
bool output_secondary_variable = true;
// Need to add variables of process to vtu even no output takes place.
processOutputData(t, x, process_id, process.getMesh(), dof_tables,
process.getProcessVariables(process_id),
process.getSecondaryVariables(),
output_secondary_variable,
process.getIntegrationPointWriter(), _process_output);
// For the staggered scheme for the coupling, only the last process, which
// gives the latest solution within a coupling loop, is allowed to make
// output.
if (!(process_id == static_cast<int>(_process_to_process_data.size()) - 1 ||
process.isMonolithicSchemeUsed()))
{
return;
}
auto output_bulk_mesh = [&]() {
outputBulkMesh(
OutputFile(_output_directory, _output_file_prefix, process_id,
timestep, t, _output_file_data_mode,
_output_file_compression),
findProcessData(process, process_id), process.getMesh(), t);
};
// Write the bulk mesh only if there are no other meshes specified for
// output, otherwise only the specified meshes are written.
if (_mesh_names_for_output.empty())
{
output_bulk_mesh();
}
for (auto const& mesh_output_name : _mesh_names_for_output)
{
if (process.getMesh().getName() == mesh_output_name)
{
output_bulk_mesh();
continue;
}
auto& mesh = *BaseLib::findElementOrError(
begin(_meshes), end(_meshes),
[&mesh_output_name](auto const& m) {
return m->getName() == mesh_output_name;
},
"Need mesh '" + mesh_output_name + "' for the output.");
std::vector<MeshLib::Node*> const& nodes = mesh.getNodes();
DBUG(
"Found %d nodes for output at mesh '%s'.",
nodes.size(), mesh.getName().c_str());
MeshLib::MeshSubset mesh_subset(mesh, nodes);
std::vector<std::unique_ptr<NumLib::LocalToGlobalIndexMap>>
mesh_dof_tables;
mesh_dof_tables.reserve(x.size());
for (std::size_t i = 0; i < x.size(); ++i)
{
mesh_dof_tables.push_back(
process.getDOFTable(i).deriveBoundaryConstrainedMap(
std::move(mesh_subset)));
}
std::vector<NumLib::LocalToGlobalIndexMap const*>
mesh_dof_table_pointers;
mesh_dof_table_pointers.reserve(mesh_dof_tables.size());
transform(cbegin(mesh_dof_tables), cend(mesh_dof_tables),
back_inserter(mesh_dof_table_pointers),
[](std::unique_ptr<NumLib::LocalToGlobalIndexMap> const& p) {
return p.get();
});
output_secondary_variable = false;
processOutputData(t, x, process_id, mesh, mesh_dof_table_pointers,
process.getProcessVariables(process_id),
process.getSecondaryVariables(),
output_secondary_variable,
process.getIntegrationPointWriter(), _process_output);
// TODO (TomFischer): add pvd support here. This can be done if the
// output is mesh related instead of process related. This would also
// allow for merging bulk mesh output and arbitrary mesh output.
OutputFile const output_file{_output_directory,
mesh.getName(),
process_id,
timestep,
t,
_output_file_data_mode,
_output_file_compression};
DBUG("output to %s", output_file.path.c_str());
makeOutput(output_file.path, mesh, output_file.compression,
output_file.data_mode);
}
INFO("[time] Output of timestep %d took %g s.", timestep,
time_output.elapsed());
}
void Output::doOutput(Process const& process,
const int process_id,
const int timestep,
const double t,
std::vector<GlobalVector*> const& x)
{
if (shallDoOutput(timestep, t))
{
doOutputAlways(process, process_id, timestep, t, x);
}
#ifdef USE_INSITU
// Note: last time step may be output twice: here and in
// doOutputLastTimestep() which throws a warning.
InSituLib::CoProcess(process.getMesh(), t, timestep, false);
#endif
}
void Output::doOutputLastTimestep(Process const& process,
const int process_id,
const int timestep,
const double t,
std::vector<GlobalVector*> const& x)
{
if (!shallDoOutput(timestep, t))
{
doOutputAlways(process, process_id, timestep, t, x);
}
#ifdef USE_INSITU
InSituLib::CoProcess(process.getMesh(), t, timestep, true);
#endif
}
void Output::doOutputNonlinearIteration(Process const& process,
const int process_id,
const int timestep, const double t,
std::vector<GlobalVector*> const& x,
const int iteration)
{
if (!_output_nonlinear_iteration_results)
{
return;
}
BaseLib::RunTime time_output;
time_output.start();
std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
for (std::size_t i = 0; i < x.size(); ++i)
{
dof_tables.push_back(&process.getDOFTable(i));
}
bool const output_secondary_variable = true;
processOutputData(t, x, process_id, process.getMesh(), dof_tables,
process.getProcessVariables(process_id),
process.getSecondaryVariables(),
output_secondary_variable,
process.getIntegrationPointWriter(), _process_output);
// For the staggered scheme for the coupling, only the last process, which
// gives the latest solution within a coupling loop, is allowed to make
// output.
if (!(process_id == static_cast<int>(_process_to_process_data.size()) - 1 ||
process.isMonolithicSchemeUsed()))
{
return;
}
// Only check whether a process data is available for output.
findProcessData(process, process_id);
std::string const output_file_name =
constructFileName(_output_file_prefix, process_id, timestep, t) +
"_nliter_" + std::to_string(iteration) + ".vtu";
std::string const output_file_path =
BaseLib::joinPaths(_output_directory, output_file_name);
DBUG("output iteration results to %s", output_file_path.c_str());
INFO("[time] Output took %g s.", time_output.elapsed());
makeOutput(output_file_path, process.getMesh(), _output_file_compression,
_output_file_data_mode);
}
} // namespace ProcessLib
| 34.491003 | 80 | 0.597004 | zhangning737 |
29f2ded57402b5eed50e07ac4ad13571c928942c | 8,753 | hpp | C++ | external/boost_1_47_0/boost/geometry/core/access.hpp | zigaosolin/Raytracer | df17f77e814b2e4b90c4a194e18cc81fa84dcb27 | [
"MIT"
] | 47 | 2015-01-01T14:37:36.000Z | 2021-04-25T07:38:07.000Z | external/boost_1_47_0/boost/geometry/core/access.hpp | zigaosolin/Raytracer | df17f77e814b2e4b90c4a194e18cc81fa84dcb27 | [
"MIT"
] | 6 | 2016-01-11T05:20:05.000Z | 2021-02-06T11:37:24.000Z | external/boost_1_47_0/boost/geometry/core/access.hpp | zigaosolin/Raytracer | df17f77e814b2e4b90c4a194e18cc81fa84dcb27 | [
"MIT"
] | 17 | 2015-01-05T15:10:43.000Z | 2021-06-22T04:59:16.000Z | // Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
// Copyright (c) 2008-2011 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to 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)
#ifndef BOOST_GEOMETRY_CORE_ACCESS_HPP
#define BOOST_GEOMETRY_CORE_ACCESS_HPP
#include <cstddef>
#include <boost/mpl/assert.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/concept_check.hpp>
#include <boost/geometry/core/coordinate_type.hpp>
#include <boost/geometry/core/point_type.hpp>
#include <boost/geometry/core/tag.hpp>
namespace boost { namespace geometry
{
/// Index of minimum corner of the box.
int const min_corner = 0;
/// Index of maximum corner of the box.
int const max_corner = 1;
namespace traits
{
/*!
\brief Traits class which gives access (get,set) to points.
\ingroup traits
\par Geometries:
/// @li point
\par Specializations should provide, per Dimension
/// @li static inline T get(G const&)
/// @li static inline void set(G&, T const&)
\tparam Geometry geometry-type
\tparam Dimension dimension to access
*/
template <typename Geometry, std::size_t Dimension, typename Enable = void>
struct access
{
BOOST_MPL_ASSERT_MSG
(
false, NOT_IMPLEMENTED_FOR_THIS_POINT_TYPE, (types<Geometry>)
);
};
/*!
\brief Traits class defining "get" and "set" to get
and set point coordinate values
\tparam Geometry geometry (box, segment)
\tparam Index index (min_corner/max_corner for box, 0/1 for segment)
\tparam Dimension dimension
\par Geometries:
- box
- segment
\par Specializations should provide:
- static inline T get(G const&)
- static inline void set(G&, T const&)
\ingroup traits
*/
template <typename Geometry, std::size_t Index, std::size_t Dimension>
struct indexed_access {};
} // namespace traits
#ifndef DOXYGEN_NO_DISPATCH
namespace core_dispatch
{
template
<
typename Tag,
typename Geometry,
typename
CoordinateType, std::size_t Dimension
>
struct access
{
//static inline T get(G const&) {}
//static inline void set(G& g, T const& value) {}
};
template
<
typename Tag,
typename Geometry,
typename CoordinateType,
std::size_t Index,
std::size_t Dimension
>
struct indexed_access
{
//static inline T get(G const&) {}
//static inline void set(G& g, T const& value) {}
};
template <typename Point, typename CoordinateType, std::size_t Dimension>
struct access<point_tag, Point, CoordinateType, Dimension>
{
static inline CoordinateType get(Point const& point)
{
return traits::access<Point, Dimension>::get(point);
}
static inline void set(Point& p, CoordinateType const& value)
{
traits::access<Point, Dimension>::set(p, value);
}
};
template
<
typename Box,
typename CoordinateType,
std::size_t Index,
std::size_t Dimension
>
struct indexed_access<box_tag, Box, CoordinateType, Index, Dimension>
{
static inline CoordinateType get(Box const& box)
{
return traits::indexed_access<Box, Index, Dimension>::get(box);
}
static inline void set(Box& b, CoordinateType const& value)
{
traits::indexed_access<Box, Index, Dimension>::set(b, value);
}
};
template
<
typename Segment,
typename CoordinateType,
std::size_t Index,
std::size_t Dimension
>
struct indexed_access<segment_tag, Segment, CoordinateType, Index, Dimension>
{
static inline CoordinateType get(Segment const& segment)
{
return traits::indexed_access<Segment, Index, Dimension>::get(segment);
}
static inline void set(Segment& segment, CoordinateType const& value)
{
traits::indexed_access<Segment, Index, Dimension>::set(segment, value);
}
};
} // namespace core_dispatch
#endif // DOXYGEN_NO_DISPATCH
#ifndef DOXYGEN_NO_DETAIL
namespace detail
{
// Two dummy tags to distinguish get/set variants below.
// They don't have to be specified by the user. The functions are distinguished
// by template signature also, but for e.g. GCC this is not enough. So give them
// a different signature.
struct signature_getset_dimension {};
struct signature_getset_index_dimension {};
} // namespace detail
#endif // DOXYGEN_NO_DETAIL
/*!
\brief Get coordinate value of a geometry (usually a point)
\details \details_get_set
\ingroup get
\tparam Dimension \tparam_dimension_required
\tparam Geometry \tparam_geometry (usually a Point Concept)
\param geometry \param_geometry (usually a point)
\param dummy \qbk_skip
\return The coordinate value of specified dimension of specified geometry
\qbk{[include reference/core/get_point.qbk]}
*/
template <std::size_t Dimension, typename Geometry>
inline typename coordinate_type<Geometry>::type get(Geometry const& geometry
, detail::signature_getset_dimension* dummy = 0
)
{
boost::ignore_unused_variable_warning(dummy);
typedef typename boost::remove_const<Geometry>::type ncg_type;
typedef core_dispatch::access
<
typename tag<Geometry>::type,
ncg_type,
typename coordinate_type<ncg_type>::type,
Dimension
> coord_access_type;
return coord_access_type::get(geometry);
}
/*!
\brief Set coordinate value of a geometry (usually a point)
\details \details_get_set
\tparam Dimension \tparam_dimension_required
\tparam Geometry \tparam_geometry (usually a Point Concept)
\param geometry geometry to assign coordinate to
\param geometry \param_geometry (usually a point)
\param value The coordinate value to set
\param dummy \qbk_skip
\ingroup set
\qbk{[include reference/core/set_point.qbk]}
*/
template <std::size_t Dimension, typename Geometry>
inline void set(Geometry& geometry
, typename coordinate_type<Geometry>::type const& value
, detail::signature_getset_dimension* dummy = 0
)
{
boost::ignore_unused_variable_warning(dummy);
typedef typename boost::remove_const<Geometry>::type ncg_type;
typedef core_dispatch::access
<
typename tag<Geometry>::type,
ncg_type,
typename coordinate_type<ncg_type>::type,
Dimension
> coord_access_type;
coord_access_type::set(geometry, value);
}
/*!
\brief get coordinate value of a Box or Segment
\details \details_get_set
\tparam Index \tparam_index_required
\tparam Dimension \tparam_dimension_required
\tparam Geometry \tparam_box_or_segment
\param geometry \param_geometry
\param dummy \qbk_skip
\return coordinate value
\ingroup get
\qbk{distinguish,with index}
\qbk{[include reference/core/get_box.qbk]}
*/
template <std::size_t Index, std::size_t Dimension, typename Geometry>
inline typename coordinate_type<Geometry>::type get(Geometry const& geometry
, detail::signature_getset_index_dimension* dummy = 0
)
{
boost::ignore_unused_variable_warning(dummy);
typedef typename boost::remove_const<Geometry>::type ncg_type;
typedef core_dispatch::indexed_access
<
typename tag<Geometry>::type,
ncg_type,
typename coordinate_type<ncg_type>::type,
Index,
Dimension
> coord_access_type;
return coord_access_type::get(geometry);
}
/*!
\brief set coordinate value of a Box / Segment
\details \details_get_set
\tparam Index \tparam_index_required
\tparam Dimension \tparam_dimension_required
\tparam Geometry \tparam_box_or_segment
\param geometry geometry to assign coordinate to
\param geometry \param_geometry
\param value The coordinate value to set
\param dummy \qbk_skip
\ingroup set
\qbk{distinguish,with index}
\qbk{[include reference/core/set_box.qbk]}
*/
template <std::size_t Index, std::size_t Dimension, typename Geometry>
inline void set(Geometry& geometry
, typename coordinate_type<Geometry>::type const& value
, detail::signature_getset_index_dimension* dummy = 0
)
{
boost::ignore_unused_variable_warning(dummy);
typedef typename boost::remove_const<Geometry>::type ncg_type;
typedef core_dispatch::indexed_access
<
typename tag<Geometry>::type, ncg_type,
typename coordinate_type<ncg_type>::type,
Index,
Dimension
> coord_access_type;
coord_access_type::set(geometry, value);
}
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_CORE_ACCESS_HPP
| 26.932308 | 80 | 0.719639 | zigaosolin |
29f329c103210dc2a61fd76e6f6bd2143f2c6575 | 3,382 | cpp | C++ | desktop/Mapper001.cpp | kevlu123/nintondo-enjoyment-service | 3ede5428a122a21f69d7f8f8fa44e89c90badfb7 | [
"MIT"
] | null | null | null | desktop/Mapper001.cpp | kevlu123/nintondo-enjoyment-service | 3ede5428a122a21f69d7f8f8fa44e89c90badfb7 | [
"MIT"
] | null | null | null | desktop/Mapper001.cpp | kevlu123/nintondo-enjoyment-service | 3ede5428a122a21f69d7f8f8fa44e89c90badfb7 | [
"MIT"
] | null | null | null | #include "Mapper001.h"
Mapper001::Mapper001(int mapperNumber, int prgChunks, int chrChunks, std::vector<uint8_t>& prg, std::vector<uint8_t>& chr) :
Mapper(mapperNumber, prgChunks, chrChunks, prg, chr)
{
sramSize = 0x2000;
sram.resize(sramSize);
Reset();
}
Mapper001::Mapper001(Savestate& state, std::vector<uint8_t>& prg, std::vector<uint8_t>& chr) :
Mapper(state, prg, chr)
{
sramSize = 0x2000;
sram.resize(sramSize);
shift = state.Pop<uint8_t>();
chrLo = state.Pop<uint8_t>();
chrHi = state.Pop<uint8_t>();
prgLo = state.Pop<uint8_t>();
ctrl = state.Pop<decltype(ctrl)>();
}
Savestate Mapper001::SaveState() const {
Savestate state = Mapper::SaveState();
state.Push<uint8_t>(shift);
state.Push<uint8_t>(chrLo);
state.Push<uint8_t>(chrHi);
state.Push<uint8_t>(prgLo);
state.Push<decltype(ctrl)>(ctrl);
return state;
}
void Mapper001::Reset() {
shift = 0b10000;
ctrl.prgBankMode = 3;
}
MirrorMode Mapper001::GetMirrorMode() const {
switch (ctrl.mirror) {
case 0:
return MirrorMode::OneScreenLo;
case 1:
return MirrorMode::OneScreenHi;
case 2:
return MirrorMode::Vertical;
case 3:
return MirrorMode::Horizontal;
default:
return MirrorMode::Hardwired;
}
}
bool Mapper001::MapCpuRead(uint16_t& addr, uint8_t& data, bool readonly) {
uint32_t newAddr;
if (addr >= 0x6000 && addr < 0x8000) {
data = sram[addr - 0x6000];
return true;
} else if (addr >= 0x8000) {
uint8_t bank = prgLo & 0x0F;
switch (ctrl.prgBankMode) {
case 0:
case 1:
newAddr = 0x8000 + ((bank & 0b1111'1110) * 0x4000) + (addr & 0x7FFF);
break;
case 2:
if (addr < 0xC000)
newAddr = 0x8000 + (addr & 0x3FFF);
else
newAddr = 0x8000 + (bank * 0x4000) + (addr & 0x3FFF);
break;
case 3:
if (addr >= 0xC000)
newAddr = 0x8000 + ((prgChunks - 1) * 0x4000) + (addr & 0x3FFF);
else
newAddr = 0x8000 + (bank * 0x4000) + (addr & 0x3FFF);
break;
}
} else
newAddr = addr;
return Mapper::MapCpuRead(newAddr, data);
}
bool Mapper001::MapCpuWrite(uint16_t& addr, uint8_t data) {
if (addr >= 0x6000 && addr < 0x8000) {
sram[addr - 0x6000] = data;
return true;
} else if (addr >= 0x8000) {
if (data & 0x80) {
Reset();
} else {
bool filled = shift & 1;
shift = (shift >> 1) | ((data & 1) << 4);
shift &= 0b11111;
if (filled) {
switch ((addr - 0x8000) / 0x2000) {
case 0:
ctrl.reg = shift;
break;
case 1:
chrLo = shift;
break;
case 2:
chrHi = shift;
break;
case 3:
prgLo = shift;
break;
}
shift = 0b10000;
}
}
}
return false;
}
bool Mapper001::MapPpuAddr(uint16_t& addr, uint32_t& newAddr) const {
newAddr = addr;
if (addr < 0x2000) {
if (ctrl.chrBankMode == 0) {
newAddr = ((chrLo & 0b1111'1110) * 0x1000) + (addr & 0x1FFF);
} else {
if (addr < 0x1000)
newAddr = (chrLo * 0x1000) + (addr & 0x0FFF);
else
newAddr = (chrHi * 0x1000) + (addr & 0x0FFF);
}
return true;
}
return false;
}
bool Mapper001::MapPpuRead(uint16_t& addr, uint8_t& data, bool readonly) {
uint32_t newAddr;
if (MapPpuAddr(addr, newAddr)) {
if (newAddr < chr.size())
data = chr[newAddr];
return true;
}
return false;
}
bool Mapper001::MapPpuWrite(uint16_t& addr, uint8_t data) {
uint32_t newAddr;
if (MapPpuAddr(addr, newAddr)) {
if (newAddr < chr.size())
chr[newAddr] = data;
return true;
}
return false;
}
| 22.25 | 124 | 0.633353 | kevlu123 |
29f4695c27a991bed7055c1f68b297f72f030928 | 7,476 | cc | C++ | ev/external/googleapis/home/ubuntu/saaras-io/falcon/build/external/googleapis/google/devtools/cloudtrace/v1/trace.grpc.pb.cc | sergiorr/yastack | 17cdc12a52ea5869f429aa8ec421c3d1d25b32e7 | [
"Apache-2.0"
] | 91 | 2018-11-24T05:33:58.000Z | 2022-03-16T05:58:05.000Z | ev/external/googleapis/home/ubuntu/saaras-io/falcon/build/external/googleapis/google/devtools/cloudtrace/v1/trace.grpc.pb.cc | sergiorr/yastack | 17cdc12a52ea5869f429aa8ec421c3d1d25b32e7 | [
"Apache-2.0"
] | 11 | 2019-06-02T23:50:17.000Z | 2022-02-04T23:58:56.000Z | ev/external/googleapis/home/ubuntu/saaras-io/falcon/build/external/googleapis/google/devtools/cloudtrace/v1/trace.grpc.pb.cc | sergiorr/yastack | 17cdc12a52ea5869f429aa8ec421c3d1d25b32e7 | [
"Apache-2.0"
] | 18 | 2018-11-24T10:35:29.000Z | 2021-04-22T07:22:10.000Z | // Generated by the gRPC C++ plugin.
// If you make any local change, they will be lost.
// source: google/devtools/cloudtrace/v1/trace.proto
#include "google/devtools/cloudtrace/v1/trace.pb.h"
#include "google/devtools/cloudtrace/v1/trace.grpc.pb.h"
#include <grpcpp/impl/codegen/async_stream.h>
#include <grpcpp/impl/codegen/async_unary_call.h>
#include <grpcpp/impl/codegen/channel_interface.h>
#include <grpcpp/impl/codegen/client_unary_call.h>
#include <grpcpp/impl/codegen/method_handler_impl.h>
#include <grpcpp/impl/codegen/rpc_service_method.h>
#include <grpcpp/impl/codegen/service_type.h>
#include <grpcpp/impl/codegen/sync_stream.h>
namespace google {
namespace devtools {
namespace cloudtrace {
namespace v1 {
static const char* TraceService_method_names[] = {
"/google.devtools.cloudtrace.v1.TraceService/ListTraces",
"/google.devtools.cloudtrace.v1.TraceService/GetTrace",
"/google.devtools.cloudtrace.v1.TraceService/PatchTraces",
};
std::unique_ptr< TraceService::Stub> TraceService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
(void)options;
std::unique_ptr< TraceService::Stub> stub(new TraceService::Stub(channel));
return stub;
}
TraceService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel)
: channel_(channel), rpcmethod_ListTraces_(TraceService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
, rpcmethod_GetTrace_(TraceService_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
, rpcmethod_PatchTraces_(TraceService_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
{}
::grpc::Status TraceService::Stub::ListTraces(::grpc::ClientContext* context, const ::google::devtools::cloudtrace::v1::ListTracesRequest& request, ::google::devtools::cloudtrace::v1::ListTracesResponse* response) {
return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ListTraces_, context, request, response);
}
::grpc::ClientAsyncResponseReader< ::google::devtools::cloudtrace::v1::ListTracesResponse>* TraceService::Stub::AsyncListTracesRaw(::grpc::ClientContext* context, const ::google::devtools::cloudtrace::v1::ListTracesRequest& request, ::grpc::CompletionQueue* cq) {
return ::grpc::internal::ClientAsyncResponseReaderFactory< ::google::devtools::cloudtrace::v1::ListTracesResponse>::Create(channel_.get(), cq, rpcmethod_ListTraces_, context, request, true);
}
::grpc::ClientAsyncResponseReader< ::google::devtools::cloudtrace::v1::ListTracesResponse>* TraceService::Stub::PrepareAsyncListTracesRaw(::grpc::ClientContext* context, const ::google::devtools::cloudtrace::v1::ListTracesRequest& request, ::grpc::CompletionQueue* cq) {
return ::grpc::internal::ClientAsyncResponseReaderFactory< ::google::devtools::cloudtrace::v1::ListTracesResponse>::Create(channel_.get(), cq, rpcmethod_ListTraces_, context, request, false);
}
::grpc::Status TraceService::Stub::GetTrace(::grpc::ClientContext* context, const ::google::devtools::cloudtrace::v1::GetTraceRequest& request, ::google::devtools::cloudtrace::v1::Trace* response) {
return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_GetTrace_, context, request, response);
}
::grpc::ClientAsyncResponseReader< ::google::devtools::cloudtrace::v1::Trace>* TraceService::Stub::AsyncGetTraceRaw(::grpc::ClientContext* context, const ::google::devtools::cloudtrace::v1::GetTraceRequest& request, ::grpc::CompletionQueue* cq) {
return ::grpc::internal::ClientAsyncResponseReaderFactory< ::google::devtools::cloudtrace::v1::Trace>::Create(channel_.get(), cq, rpcmethod_GetTrace_, context, request, true);
}
::grpc::ClientAsyncResponseReader< ::google::devtools::cloudtrace::v1::Trace>* TraceService::Stub::PrepareAsyncGetTraceRaw(::grpc::ClientContext* context, const ::google::devtools::cloudtrace::v1::GetTraceRequest& request, ::grpc::CompletionQueue* cq) {
return ::grpc::internal::ClientAsyncResponseReaderFactory< ::google::devtools::cloudtrace::v1::Trace>::Create(channel_.get(), cq, rpcmethod_GetTrace_, context, request, false);
}
::grpc::Status TraceService::Stub::PatchTraces(::grpc::ClientContext* context, const ::google::devtools::cloudtrace::v1::PatchTracesRequest& request, ::google::protobuf::Empty* response) {
return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_PatchTraces_, context, request, response);
}
::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* TraceService::Stub::AsyncPatchTracesRaw(::grpc::ClientContext* context, const ::google::devtools::cloudtrace::v1::PatchTracesRequest& request, ::grpc::CompletionQueue* cq) {
return ::grpc::internal::ClientAsyncResponseReaderFactory< ::google::protobuf::Empty>::Create(channel_.get(), cq, rpcmethod_PatchTraces_, context, request, true);
}
::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* TraceService::Stub::PrepareAsyncPatchTracesRaw(::grpc::ClientContext* context, const ::google::devtools::cloudtrace::v1::PatchTracesRequest& request, ::grpc::CompletionQueue* cq) {
return ::grpc::internal::ClientAsyncResponseReaderFactory< ::google::protobuf::Empty>::Create(channel_.get(), cq, rpcmethod_PatchTraces_, context, request, false);
}
TraceService::Service::Service() {
AddMethod(new ::grpc::internal::RpcServiceMethod(
TraceService_method_names[0],
::grpc::internal::RpcMethod::NORMAL_RPC,
new ::grpc::internal::RpcMethodHandler< TraceService::Service, ::google::devtools::cloudtrace::v1::ListTracesRequest, ::google::devtools::cloudtrace::v1::ListTracesResponse>(
std::mem_fn(&TraceService::Service::ListTraces), this)));
AddMethod(new ::grpc::internal::RpcServiceMethod(
TraceService_method_names[1],
::grpc::internal::RpcMethod::NORMAL_RPC,
new ::grpc::internal::RpcMethodHandler< TraceService::Service, ::google::devtools::cloudtrace::v1::GetTraceRequest, ::google::devtools::cloudtrace::v1::Trace>(
std::mem_fn(&TraceService::Service::GetTrace), this)));
AddMethod(new ::grpc::internal::RpcServiceMethod(
TraceService_method_names[2],
::grpc::internal::RpcMethod::NORMAL_RPC,
new ::grpc::internal::RpcMethodHandler< TraceService::Service, ::google::devtools::cloudtrace::v1::PatchTracesRequest, ::google::protobuf::Empty>(
std::mem_fn(&TraceService::Service::PatchTraces), this)));
}
TraceService::Service::~Service() {
}
::grpc::Status TraceService::Service::ListTraces(::grpc::ServerContext* context, const ::google::devtools::cloudtrace::v1::ListTracesRequest* request, ::google::devtools::cloudtrace::v1::ListTracesResponse* response) {
(void) context;
(void) request;
(void) response;
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
::grpc::Status TraceService::Service::GetTrace(::grpc::ServerContext* context, const ::google::devtools::cloudtrace::v1::GetTraceRequest* request, ::google::devtools::cloudtrace::v1::Trace* response) {
(void) context;
(void) request;
(void) response;
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
::grpc::Status TraceService::Service::PatchTraces(::grpc::ServerContext* context, const ::google::devtools::cloudtrace::v1::PatchTracesRequest* request, ::google::protobuf::Empty* response) {
(void) context;
(void) request;
(void) response;
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
} // namespace google
} // namespace devtools
} // namespace cloudtrace
} // namespace v1
| 60.780488 | 270 | 0.754548 | sergiorr |
29f604b60d7784728e793b29827ffabfa74b4f48 | 451 | cpp | C++ | src/EscapeButton.cpp | ern0/escapebutton | c6d4351a3b9662482a9c9c89e6cdff840afac06e | [
"MIT"
] | null | null | null | src/EscapeButton.cpp | ern0/escapebutton | c6d4351a3b9662482a9c9c89e6cdff840afac06e | [
"MIT"
] | null | null | null | src/EscapeButton.cpp | ern0/escapebutton | c6d4351a3b9662482a9c9c89e6cdff840afac06e | [
"MIT"
] | null | null | null | #include "DigiKeyboard.h"
#define PIN_BUTTON 1
#define KEY_ESC 41
void setup() {
} // setup()
void loop() {
while ( digitalRead(PIN_BUTTON) == 0 ) {
DigiKeyboard.delay(10);
}
DigiKeyboard.update();
DigiKeyboard.sendKeyPress(KEY_ESC,0);
DigiKeyboard.delay(200);
DigiKeyboard.sendKeyPress(0,0);
while ( digitalRead(PIN_BUTTON) == 1 ) {
DigiKeyboard.delay(10);
}
DigiKeyboard.delay(100);
} // loop()
| 13.666667 | 42 | 0.634146 | ern0 |
29f7f62cd9803623d4ff05c43d79813e7bc0a2aa | 730 | hpp | C++ | libs/pika/algorithms/include/pika/parallel/util/detail/handle_exception_termination_handler.hpp | pika-org/pika | c80f542b2432a7f108fcfba31a5fe5073ad2b3e1 | [
"BSL-1.0"
] | 13 | 2022-01-17T12:01:48.000Z | 2022-03-16T10:03:14.000Z | libs/pika/algorithms/include/pika/parallel/util/detail/handle_exception_termination_handler.hpp | pika-org/pika | c80f542b2432a7f108fcfba31a5fe5073ad2b3e1 | [
"BSL-1.0"
] | 163 | 2022-01-17T17:36:45.000Z | 2022-03-31T17:42:57.000Z | libs/pika/algorithms/include/pika/parallel/util/detail/handle_exception_termination_handler.hpp | pika-org/pika | c80f542b2432a7f108fcfba31a5fe5073ad2b3e1 | [
"BSL-1.0"
] | 4 | 2022-01-19T08:44:22.000Z | 2022-01-31T23:16:21.000Z | // Copyright (c) 2020 ETH Zurich
//
// SPDX-License-Identifier: BSL-1.0
// 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)
#pragma once
#include <pika/config.hpp>
#include <pika/functional/function.hpp>
namespace pika { namespace parallel { namespace util { namespace detail {
using parallel_exception_termination_handler_type =
pika::util::function<void()>;
PIKA_EXPORT void set_parallel_exception_termination_handler(
parallel_exception_termination_handler_type f);
PIKA_NORETURN PIKA_EXPORT void parallel_exception_termination_handler();
}}}} // namespace pika::parallel::util::detail
| 34.761905 | 80 | 0.757534 | pika-org |
29f88a19274733af436b52ae6fa08dcc04483e2b | 1,312 | cpp | C++ | apps/camera-calib/camera_calib_guiApp.cpp | wstnturner/mrpt | b0be3557a4cded6bafff03feb28f7fa1f75762a3 | [
"BSD-3-Clause"
] | 38 | 2015-01-04T05:24:26.000Z | 2015-07-17T00:30:02.000Z | apps/camera-calib/camera_calib_guiApp.cpp | wstnturner/mrpt | b0be3557a4cded6bafff03feb28f7fa1f75762a3 | [
"BSD-3-Clause"
] | 40 | 2015-01-03T22:43:00.000Z | 2015-07-17T18:52:59.000Z | apps/camera-calib/camera_calib_guiApp.cpp | wstnturner/mrpt | b0be3557a4cded6bafff03feb28f7fa1f75762a3 | [
"BSD-3-Clause"
] | 41 | 2015-01-06T12:32:19.000Z | 2017-05-30T15:50:13.000Z | /* +------------------------------------------------------------------------+
| Mobile Robot Programming Toolkit (MRPT) |
| https://www.mrpt.org/ |
| |
| Copyright (c) 2005-2022, 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 "camera_calib_guiApp.h"
//(*AppHeaders
#include <wx/image.h>
#include "camera_calib_guiMain.h"
//*)
#include <wx/log.h>
IMPLEMENT_APP(camera_calib_guiApp)
bool camera_calib_guiApp::OnInit()
{
// Starting in wxWidgets 2.9.0, we must reset numerics locale to "C",
// if we want numbers to use "." in all countries. The App::OnInit() is a
// perfect place to undo
// the default wxWidgets settings. (JL @ Sep-2009)
wxSetlocale(LC_NUMERIC, wxString(wxT("C")));
//(*AppInitialize
bool wxsOK = true;
wxInitAllImageHandlers();
if (wxsOK)
{
camera_calib_guiDialog Dlg(nullptr);
SetTopWindow(&Dlg);
Dlg.ShowModal();
wxsOK = false;
}
//*)
return wxsOK;
}
| 30.511628 | 80 | 0.508384 | wstnturner |
29fb698ce1ea80a661974d8984fd8fe4e7c1b45d | 2,879 | cpp | C++ | src/lgfx/v1/platforms/esp32/Light_PWM.cpp | wakwak-koba/M5GFX | a0632b40590a49c0959209a2878225a51f167597 | [
"MIT"
] | null | null | null | src/lgfx/v1/platforms/esp32/Light_PWM.cpp | wakwak-koba/M5GFX | a0632b40590a49c0959209a2878225a51f167597 | [
"MIT"
] | null | null | null | src/lgfx/v1/platforms/esp32/Light_PWM.cpp | wakwak-koba/M5GFX | a0632b40590a49c0959209a2878225a51f167597 | [
"MIT"
] | null | null | null | /*----------------------------------------------------------------------------/
Lovyan GFX - Graphics library for embedded devices.
Original Source:
https://github.com/lovyan03/LovyanGFX/
Licence:
[FreeBSD](https://github.com/lovyan03/LovyanGFX/blob/master/license.txt)
Author:
[lovyan03](https://twitter.com/lovyan03)
Contributors:
[ciniml](https://github.com/ciniml)
[mongonta0716](https://github.com/mongonta0716)
[tobozo](https://github.com/tobozo)
/----------------------------------------------------------------------------*/
#if defined (ESP32) || defined (CONFIG_IDF_TARGET_ESP32) || defined (CONFIG_IDF_TARGET_ESP32S2) || defined (ESP_PLATFORM)
#include "Light_PWM.hpp"
#if defined ARDUINO
#include <esp32-hal-ledc.h>
#else
#include <driver/ledc.h>
#endif
namespace lgfx
{
inline namespace v1
{
//----------------------------------------------------------------------------
void Light_PWM::init(std::uint8_t brightness)
{
#ifdef ARDUINO
ledcSetup(_cfg.pwm_channel, _cfg.freq, 8);
ledcAttachPin(_cfg.pin_bl, _cfg.pwm_channel);
#else
static ledc_channel_config_t ledc_channel;
{
ledc_channel.gpio_num = (gpio_num_t)_cfg.pin_bl;
#if SOC_LEDC_SUPPORT_HS_MODE
ledc_channel.speed_mode = LEDC_HIGH_SPEED_MODE;
#else
ledc_channel.speed_mode = LEDC_LOW_SPEED_MODE;
#endif
ledc_channel.channel = (ledc_channel_t)_cfg.pwm_channel;
ledc_channel.intr_type = LEDC_INTR_DISABLE;
ledc_channel.timer_sel = (ledc_timer_t)((_cfg.pwm_channel >> 1) & 3);
ledc_channel.duty = _cfg.invert ? 256 : 0;
ledc_channel.hpoint = 0;
};
ledc_channel_config(&ledc_channel);
static ledc_timer_config_t ledc_timer;
{
#if SOC_LEDC_SUPPORT_HS_MODE
ledc_timer.speed_mode = LEDC_HIGH_SPEED_MODE; // timer mode
#else
ledc_timer.speed_mode = LEDC_LOW_SPEED_MODE;
#endif
ledc_timer.duty_resolution = (ledc_timer_bit_t)8; // resolution of PWM duty
ledc_timer.freq_hz = _cfg.freq; // frequency of PWM signal
ledc_timer.timer_num = ledc_channel.timer_sel; // timer index
};
ledc_timer_config(&ledc_timer);
#endif
setBrightness(brightness);
}
void Light_PWM::setBrightness(std::uint8_t brightness)
{
if (_cfg.invert) brightness = ~brightness;
std::uint32_t duty = brightness + (brightness >> 7);
#ifdef ARDUINO
ledcWrite(_cfg.pwm_channel, duty);
#elif SOC_LEDC_SUPPORT_HS_MODE
ledc_set_duty(LEDC_HIGH_SPEED_MODE, (ledc_channel_t)_cfg.pwm_channel, duty);
ledc_update_duty(LEDC_HIGH_SPEED_MODE, (ledc_channel_t)_cfg.pwm_channel);
#else
ledc_set_duty(LEDC_LOW_SPEED_MODE, (ledc_channel_t)_cfg.pwm_channel, duty);
ledc_update_duty(LEDC_LOW_SPEED_MODE, (ledc_channel_t)_cfg.pwm_channel);
#endif
}
//----------------------------------------------------------------------------
}
}
#endif | 29.080808 | 121 | 0.646058 | wakwak-koba |
29ffb493e8e7fc7988dd7e0e258966b5ab0c6872 | 1,346 | hpp | C++ | roguelike/hud.hpp | LoginLEE/HKUST-COMP2012h-2D-Shooting-Game | d03812a4a8cba8d31873157d71818b8c67d495fd | [
"MIT"
] | null | null | null | roguelike/hud.hpp | LoginLEE/HKUST-COMP2012h-2D-Shooting-Game | d03812a4a8cba8d31873157d71818b8c67d495fd | [
"MIT"
] | null | null | null | roguelike/hud.hpp | LoginLEE/HKUST-COMP2012h-2D-Shooting-Game | d03812a4a8cba8d31873157d71818b8c67d495fd | [
"MIT"
] | null | null | null | #pragma once
#include <SFML/Graphics.hpp>
#include "global_defines.hpp"
#include "game_entity.hpp"
#include "utils.hpp"
/**
* @brief Class for the Entity representing the HUD
*/
class HUD : public GameEntity {
private:
protected:
public:
/**
* @brief Create the HUD Entity
*
* @param _manager The global GameManager pointer
* @param parent The parent GameEntity node
*/
HUD(GameManager *_manager, GameEntity *parent);
/**
* @brief Update the HUD
*/
virtual void update() override;
/**
* @brief Draw the HUD
*
* @param renderer The RenderTarget to draw to
*/
virtual void draw(sf::RenderTarget &renderer) const override;
/**
* @brief font for the HUD
*/
static sf::Font entryFont;
/**
* @brief Constructs the Gun Info Pane as a Drawable Group
*
* @param gun The gun
* @param compareGun The gun to compare to
*
* @return Drawable Group of Gun Info
*/
static utils::DrawableGroup craftGunInfo(Gun *gun, Gun *compareGun = nullptr);
/**
* @brief Construct the Mini Gun Info Pane as a Drawable Group
*
* @param gun The gun
*
* @return Drawable Group of Gun Info
*/
static utils::DrawableGroup craftGunMiniInfo(Gun *gun);
}; | 22.065574 | 80 | 0.603269 | LoginLEE |
4b00dc2f46a491b8aa4ecf2eea156d72eeb6c052 | 792 | cpp | C++ | srcs/PointTEST.cpp | ardasdasdas/point-cloud-processing | 68f08d3c881399bbdd10913bcce8b0ae659a8427 | [
"MIT"
] | 4 | 2020-12-16T08:29:18.000Z | 2021-03-01T10:53:51.000Z | srcs/PointTEST.cpp | pinarkizilarslan/point-cloud-processing | 68f08d3c881399bbdd10913bcce8b0ae659a8427 | [
"MIT"
] | null | null | null | srcs/PointTEST.cpp | pinarkizilarslan/point-cloud-processing | 68f08d3c881399bbdd10913bcce8b0ae659a8427 | [
"MIT"
] | 4 | 2020-07-22T21:53:09.000Z | 2022-01-19T13:42:42.000Z | #include<iostream>
#include"Point.h"
using namespace std;
/**
* @file : PointCloudTEST.cpp
* @Author : Muzaffer Arda Uslu ([email protected])
* @date : 12 Aralik 2019, Persembe
* @brief : Bu kod parcacigi olusturulan Point sinifinin dogru calisip calismadigini kontrol etmek amaciyla yazilmistir.
*/
int main() {
Point P1, P2;
P1.setX(1);
P1.setY(2);
P1.setZ(3);
P2.setX(4);
P2.setY(5);
P2.setZ(6);
cout << "P1 x->" << P1.getX() << " y->" << P1.getY() << " z->" << P1.getZ() << endl;
cout << "P2 x->" << P2.getX() << " y->" << P2.getY() << " z->" << P2.getZ() << endl;
if (P1 == P2)
cout << "Point nesneleri ayni!" << endl;
else
cout << "Point nesneleri ayni degil!" << endl;
cout << "P1 ve P2 arasindaki uzaklik -> " << P1.distance(P2) << endl;
system("pause");
} | 24.75 | 119 | 0.594697 | ardasdasdas |
4b00deb2f7b01bf01397629483145b02f571232f | 126,677 | cpp | C++ | Tools/STM32FW/STM32Cube_FW_F7_V1.16.2/Projects/STM32F769I_EVAL/Demonstrations/TouchGFX/Gui/generated/images/src/Movie/toggle_off.cpp | ramkumarkoppu/NUCLEO-F767ZI-ESW | 85e129d71ee8eccbd0b94b5e07e75b6b91679ee8 | [
"MIT"
] | null | null | null | Tools/STM32FW/STM32Cube_FW_F7_V1.16.2/Projects/STM32F769I_EVAL/Demonstrations/TouchGFX/Gui/generated/images/src/Movie/toggle_off.cpp | ramkumarkoppu/NUCLEO-F767ZI-ESW | 85e129d71ee8eccbd0b94b5e07e75b6b91679ee8 | [
"MIT"
] | null | null | null | Tools/STM32FW/STM32Cube_FW_F7_V1.16.2/Projects/STM32F769I_EVAL/Demonstrations/TouchGFX/Gui/generated/images/src/Movie/toggle_off.cpp | ramkumarkoppu/NUCLEO-F767ZI-ESW | 85e129d71ee8eccbd0b94b5e07e75b6b91679ee8 | [
"MIT"
] | null | null | null | // Generated by imageconverter. Please, do not edit!
#include <touchgfx/hal/Config.hpp>
LOCATION_EXTFLASH_PRAGMA
KEEP extern const unsigned char _toggle_off[] LOCATION_EXTFLASH_ATTRIBUTE = { // 90x70 ARGB8888 pixels.
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x0c,
0xff,0xff,0xff,0x1b,0xff,0xff,0xff,0x27,0xff,0xff,0xff,0x2e,0xff,0xff,0xff,0x32,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x32,0xff,0xff,0xff,0x2e,0xff,0xff,0xff,0x27,0xff,0xff,0xff,0x1c,0xff,0xff,0xff,0x0c,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x14,0xff,0xff,0xff,0x2c,0xf6,0xf5,0xf2,0x35,0xdf,0xdc,0xd3,0x3b,0xcf,0xcb,0xbe,0x40,0xc4,0xbf,0xaf,0x44,0xc1,0xbc,0xab,0x45,0xc2,0xbc,0xac,0x45,0xc6,0xc2,0xb3,0x43,
0xcf,0xcb,0xbe,0x40,0xdf,0xdc,0xd3,0x3b,0xf6,0xf5,0xf2,0x35,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x2c,0xff,0xff,0xff,0x14,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x07,
0xff,0xff,0xff,0x28,0xf2,0xf1,0xed,0x36,0xd5,0xd2,0xc6,0x3e,0xb7,0xb1,0x9e,0x49,0x9e,0x97,0x7d,0x56,0x8f,0x86,0x68,0x61,0x87,0x7d,0x5d,0x68,0x84,0x79,0x59,0x6b,0x84,0x79,0x59,0x6b,0x88,0x7e,0x5e,0x67,0x8f,0x86,0x68,0x61,0x9e,0x97,0x7d,0x56,0xb7,0xb1,0x9e,0x49,0xd5,0xd2,0xc6,0x3e,0xf2,0xf1,0xed,0x36,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x28,0xff,0xff,0xff,0x07,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x0d,0xf6,0xf5,0xf2,0x31,0xd8,0xd5,0xcb,0x3d,0xb6,0xb0,0x9c,0x4a,0x97,0x8f,0x73,0x5b,0x96,0x8c,0x71,0x75,0xca,0xc6,0xb8,0xae,0xe8,0xe6,0xe0,0xd7,
0xf6,0xf5,0xf3,0xf0,0xfd,0xfd,0xfd,0xfc,0xfc,0xfb,0xfb,0xf9,0xf3,0xf2,0xef,0xeb,0xe8,0xe6,0xe0,0xd7,0xca,0xc6,0xb8,0xae,0x96,0x8c,0x71,0x75,0x97,0x8f,0x73,0x5b,0xb6,0xb0,0x9c,0x4a,0xd8,0xd5,0xcb,0x3d,0xf6,0xf5,0xf2,0x35,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x2f,0xff,0xff,0xff,0x0c,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x0e,0xf6,0xf5,0xf2,0x34,0xcc,0xc8,0xbb,0x41,0x9e,0x97,0x7d,0x56,0x8d,0x82,0x65,0x70,0xd1,0xcd,0xc1,0xb8,0xfb,0xfa,0xf9,0xf7,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xfb,0xfa,0xf9,0xf7,0xd1,0xcd,0xc1,0xb9,0x8e,0x84,0x66,0x70,0x9e,0x97,0x7d,0x56,0xcc,0xc8,0xbb,0x41,0xf6,0xf5,0xf2,0x35,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x32,0xff,0xff,0xff,0x0e,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x08,0xf7,0xf5,0xf3,0x32,0xcf,0xcb,0xbe,0x40,0x9a,0x92,0x77,0x59,0x9d,0x94,0x7b,0x83,0xf2,0xf1,0xed,0xe9,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf2,0xf1,0xed,0xe9,0x9d,0x94,0x7b,0x83,0x9a,0x92,0x77,0x59,0xcf,0xcb,0xbe,0x40,
0xf7,0xf5,0xf3,0x35,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x31,0xff,0xff,0xff,0x08,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x01,0xff,0xff,0xff,0x28,0xdc,0xd9,0xd0,0x3c,0xa0,0x98,0x7f,0x55,0x9a,0x90,0x76,0x81,0xf7,0xf6,0xf4,0xf1,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf7,0xf6,0xf4,0xf1,0x9a,0x90,0x76,0x81,0xa0,0x98,0x7f,0x55,0xdc,0xd9,0xd0,0x3c,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x28,0xff,0xff,0xff,0x01,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x14,0xf2,0xf1,0xed,0x36,0xb6,0xb0,0x9c,0x4a,
0x8e,0x83,0x66,0x6f,0xef,0xee,0xea,0xe4,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0xee,0xea,0xe4,0x8f,0x85,0x68,0x6f,0xb6,0xb0,0x9c,0x4a,0xf2,0xf1,0xed,0x36,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x14,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x2c,0xd5,0xd2,0xc6,0x3e,0x97,0x8f,0x73,0x5b,0xd0,0xcc,0xbf,0xb8,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xd1,0xcd,0xc1,0xb8,0x95,0x8d,0x71,0x5c,0xd5,0xd2,0xc6,0x3e,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x2c,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0xff,0xff,0xff,0x0d,0xf6,0xf5,0xf2,0x35,0xb7,0xb1,0x9e,0x49,0x97,0x8d,0x72,0x75,0xfb,0xfb,0xfa,0xf7,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfb,0xfb,0xfa,0xf7,0x97,0x8d,0x72,0x75,0xb7,0xb1,0x9e,0x49,0xf6,0xf5,0xf2,0x35,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x0d,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x1b,0xdf,0xdc,0xd3,0x3b,0x9e,0x97,0x7d,0x56,0xcb,0xc7,0xb9,0xaf,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xcb,0xc7,0xb9,0xaf,0x9e,0x97,0x7d,0x56,0xdf,0xdc,0xd3,0x3b,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x1b,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x27,0xcf,0xcb,0xbe,0x40,0x8f,0x86,0x68,0x61,0xe7,0xe5,0xdf,0xd7,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe8,0xe6,0xe0,0xd7,0x8f,0x86,0x68,0x61,0xcf,0xcb,0xbe,0x40,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x27,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x2e,0xc4,0xbf,0xaf,0x44,
0x87,0x7d,0x5d,0x68,0xf7,0xf6,0xf4,0xf0,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf7,0xf6,0xf4,0xf0,0x87,0x7d,0x5d,0x68,0xc4,0xbf,0xaf,0x44,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x2e,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x32,0xc1,0xbc,0xab,0x45,0x84,0x79,0x59,0x6b,0xfd,0xfd,0xfd,0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xfd,0xfd,0xfd,0xfc,0x84,0x79,0x59,0x6b,0xc1,0xbc,0xab,0x45,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x32,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x32,0xc2,0xbc,0xac,0x45,0x84,0x79,0x59,0x6b,0xfc,0xfb,0xfb,0xf8,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfd,0xfd,0xfd,0xfc,0x84,0x79,0x59,0x6b,0xc1,0xbc,0xab,0x45,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x32,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x2e,0xc6,0xc2,0xb3,0x43,0x88,0x7e,0x5e,0x67,0xf3,0xf2,0xef,0xec,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf7,0xf6,0xf4,0xf0,0x87,0x7d,0x5d,0x68,0xc4,0xbf,0xaf,0x44,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x2e,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x27,0xcf,0xcb,0xbe,0x40,0x8f,0x86,0x68,0x61,0xe7,0xe5,0xdf,0xd7,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe8,0xe6,0xe0,0xd7,0x8f,0x86,0x68,0x61,
0xcf,0xcb,0xbe,0x40,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x27,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0xff,0xff,0xff,0x1c,0xdf,0xdc,0xd3,0x3b,0x9e,0x97,0x7d,0x56,0xcb,0xc7,0xb9,0xaf,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xcb,0xc7,0xb9,0xaf,0x9e,0x97,0x7d,0x56,0xdf,0xdc,0xd3,0x3b,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x1b,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x0d,0xf6,0xf5,0xf2,0x35,0xb7,0xb1,0x9e,0x49,0x97,0x8d,0x72,0x75,0xfb,0xfb,0xfa,0xf7,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xfb,0xfb,0xfa,0xf7,0x97,0x8d,0x72,0x75,0xb7,0xb1,0x9e,0x49,0xf6,0xf5,0xf2,0x35,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x0d,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x2c,0xd5,0xd2,0xc6,0x3e,0x95,0x8d,0x71,0x5c,0xd1,0xcd,0xc1,0xb8,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xd1,0xcd,0xc1,0xb8,0x95,0x8d,0x71,0x5c,0xd5,0xd2,0xc6,0x3e,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x2c,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x14,
0xf2,0xf1,0xed,0x36,0xb6,0xb0,0x9c,0x4a,0x8e,0x84,0x66,0x70,0xf2,0xf1,0xed,0xe8,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf2,0xf1,0xed,0xe9,0x8e,0x84,0x66,0x70,0xb6,0xb0,0x9c,0x4a,0xf2,0xf1,0xed,0x36,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x14,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x01,0xff,0xff,0xff,0x29,0xd8,0xd5,0xcb,0x3d,0x9e,0x97,0x7d,0x56,0xa0,0x98,0x7f,0x85,0xf7,0xf7,0xf5,0xf2,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf7,0xf7,0xf5,0xf1,0xa0,0x98,0x7f,0x85,0x9e,0x97,0x7d,0x56,
0xd8,0xd5,0xcb,0x3d,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x29,0xff,0xff,0xff,0x01,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x08,0xf6,0xf5,0xf2,0x33,0xcc,0xc8,0xbb,0x41,0x9a,0x92,0x77,0x59,0x9e,0x95,0x7c,0x83,0xf2,0xf1,0xed,0xe9,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf2,0xf1,0xed,0xe9,0x9d,0x94,0x7b,0x83,0x9a,0x92,0x77,0x59,0xcc,0xc8,0xbb,0x41,0xf6,0xf5,0xf2,0x35,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x31,0xff,0xff,0xff,0x08,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x0f,
0xf6,0xf5,0xf2,0x34,0xcc,0xc8,0xbb,0x41,0x9e,0x97,0x7d,0x56,0x8e,0x84,0x66,0x70,0xd1,0xcd,0xc1,0xb9,0xfb,0xfa,0xf9,0xf7,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfb,0xfa,0xf9,0xf7,0xd1,0xcd,0xc1,0xb9,
0x8e,0x84,0x66,0x70,0x9e,0x97,0x7d,0x56,0xcc,0xc8,0xbb,0x41,0xf6,0xf5,0xf2,0x35,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x32,0xff,0xff,0xff,0x0f,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x0f,0xf6,0xf5,0xf2,0x33,0xd8,0xd5,0xcb,0x3d,0xb6,0xb0,0x9c,0x4a,0x97,0x8f,0x73,0x5b,0x96,0x8c,0x71,0x75,
0xcb,0xc7,0xb9,0xaf,0xe8,0xe6,0xe0,0xd7,0xf6,0xf5,0xf3,0xf0,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xf6,0xf5,0xf3,0xf0,0xe8,0xe6,0xe0,0xd7,0xcb,0xc7,0xb9,0xaf,0x96,0x8c,0x71,0x75,0x97,0x8f,0x73,0x5b,0xb6,0xb0,0x9c,0x4a,0xd8,0xd5,0xcb,0x3d,0xf6,0xf5,0xf2,0x35,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x31,0xff,0xff,0xff,0x0f,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x08,0xff,0xff,0xff,0x29,0xf2,0xf1,0xed,0x36,0xd5,0xd2,0xc6,0x3e,0xb7,0xb1,0x9e,0x49,0x9e,0x97,0x7d,0x56,0x8f,0x86,0x68,0x61,0x87,0x7d,0x5d,0x68,0x82,0x78,0x57,0x6c,0x82,0x78,0x57,0x6c,0x87,0x7d,0x5d,0x68,
0x8f,0x86,0x68,0x61,0x9e,0x97,0x7d,0x56,0xb7,0xb1,0x9e,0x49,0xd5,0xd2,0xc6,0x3e,0xf2,0xf1,0xed,0x36,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x29,0xff,0xff,0xff,0x08,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x14,0xff,0xff,0xff,0x2c,0xf6,0xf5,0xf2,0x35,0xdf,0xdc,0xd3,0x3b,0xcf,0xcb,0xbe,0x40,0xc4,0xbf,0xaf,0x44,0xc1,0xbc,0xab,0x45,0xc1,0xbc,0xab,0x45,0xc4,0xbf,0xaf,0x44,0xcf,0xcb,0xbe,0x40,0xdf,0xdc,0xd3,0x3b,0xf6,0xf5,0xf2,0x35,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x2c,0xff,0xff,0xff,0x14,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x0c,0xff,0xff,0xff,0x1c,0xff,0xff,0xff,0x27,
0xff,0xff,0xff,0x2e,0xff,0xff,0xff,0x32,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,
0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x33,0xff,0xff,0xff,0x32,0xff,0xff,0xff,0x2e,0xff,0xff,0xff,0x27,0xff,0xff,0xff,0x1c,0xff,0xff,0xff,0x0c,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,0x42,0x32,0x00,0x00,
0x42,0x32,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00
};
| 273.010776 | 320 | 0.797106 | ramkumarkoppu |
4b0164ba134084644840e2a2a5b69c424381e4e0 | 245 | cpp | C++ | Tips template/关于声明语句与变量命名冲突的一些说法.cpp | FunamiYui/PAT_Code_Akari | 52e06689b6bf8177c43ab9256719258c47e80b25 | [
"MIT"
] | null | null | null | Tips template/关于声明语句与变量命名冲突的一些说法.cpp | FunamiYui/PAT_Code_Akari | 52e06689b6bf8177c43ab9256719258c47e80b25 | [
"MIT"
] | null | null | null | Tips template/关于声明语句与变量命名冲突的一些说法.cpp | FunamiYui/PAT_Code_Akari | 52e06689b6bf8177c43ab9256719258c47e80b25 | [
"MIT"
] | null | null | null | /*
如果引用了iostream或者vector，又加了using namespace std;这条语句，就尽量不要使用hash这样的变量名
因为这样会跟std命名空间里面的hash变量名冲突，导致编译失败或者运行出错
这种情况解决办法要么单独用std，比如std::cin、std::endl，要么直接避开hash作为变量名(可以改用HashTable)
类似的还有math.h的y1变量名，如果将其作为全局变量，就会导致编译错误
若编译有报错或者运行莫名出错，则可以考虑这些因素
*/
| 30.625 | 68 | 0.877551 | FunamiYui |
4b02608e718aaea1004ac3523b8224e535d7cba6 | 2,240 | cpp | C++ | alarm/set.cpp | joeljk13/WinAlarm | 1f37c0ffb2d29aec5f57c11a9b0a029800d850ce | [
"MIT"
] | 1 | 2015-02-10T15:30:36.000Z | 2015-02-10T15:30:36.000Z | alarm/set.cpp | joeljk13/WinAlarm | 1f37c0ffb2d29aec5f57c11a9b0a029800d850ce | [
"MIT"
] | null | null | null | alarm/set.cpp | joeljk13/WinAlarm | 1f37c0ffb2d29aec5f57c11a9b0a029800d850ce | [
"MIT"
] | null | null | null | #include "main.h"
#include "alarm.h"
#include "file.h"
#include <stdio.h>
#include <string.h>
static void
print_help()
{
fputs("Usage: alarm set [DATE] [TIME] [OPTIONS]\n\n"
"Sets an alarm at the given time.\n\n"
"If --help or --version (or their short versions) are used as\n"
"options, only the first one will be used, and no time or date\n"
"should be specified. Otherwise, TIME is mandatory.\n\n"
"DATE uses the format is YYYY-MM-DD. If the date is omitted,\n"
"today's date is used if the time has not already passed;\n"
"otherwise tomorrow's date is used.\n\n"
"TIME is mandatory if neither --help or --version is used.\n"
"The format for time is HH:MM:SS, using a 24-hour system.\n\n"
"If multiple alarm levels are given, most severe one is used.\n\n"
"OPTIONS can be any of the following, in (almost) any order:\n"
"\t--help (-h) - display this help. If specified, this must be the first\n"
"\t\toption, and neither TIME nor DATE can be specified.\n"
"\t--version (-v) - display the version. If specified, this must be the\n"
"\t\tfirst option, and neither TIME nor DATE can be specified.\n"
"\t--critical (-c) - the alarm is of critical level\n"
"\t--warning (-w) - the alarm is of warning level\n"
"\t--nosleep (-ns) - prevent the user from sleeping this alarm\n"
"\t--nosound (-nd) - prevent the alarm from making sound\n"
"\t--novisual (-nv) - prevent the alarm from making visual effects.\n"
"\t--nowake (-nk) - only raise an alarm if the computer is already awake.\n",
stdout);
}
static void
print_version()
{
fputs("alarm set - version 1.0\n"
"last updated 2014-10-03\n", stdout);
}
int
set_main(int argc, char **argv, const char *argstr)
{
Alarm alarm;
FILE *f;
if (argc == 0) {
print_help();
return 0;
}
if (strcmp(argv[0], "--help") == 0 || strcmp(argv[0], "-h") == 0) {
print_help();
return 0;
}
if (strcmp(argv[0], "--version") == 0 || strcmp(argv[0], "-v") == 0) {
print_version();
return 0;
}
if (alarm.read_arg_str(argstr) != 0) {
print_help();
return 1;
}
f = fopen(FILE_NAME, "a");
if (f == NULL) {
file_err("a");
return 1;
}
if (alarm.print_file(f) != 0) {
fclose(f);
return 1;
}
fclose(f);
return 0;
} | 24.888889 | 79 | 0.638839 | joeljk13 |
4b050abfe832396860ef6deedd532728f4f02b51 | 131 | cpp | C++ | Data Structures/Queues/QueueArray.cpp | anjali9811/Programming-in-Cpp | 02e80e045a7fb20f8970fcdae68c08bdf27f95b8 | [
"Apache-2.0"
] | null | null | null | Data Structures/Queues/QueueArray.cpp | anjali9811/Programming-in-Cpp | 02e80e045a7fb20f8970fcdae68c08bdf27f95b8 | [
"Apache-2.0"
] | null | null | null | Data Structures/Queues/QueueArray.cpp | anjali9811/Programming-in-Cpp | 02e80e045a7fb20f8970fcdae68c08bdf27f95b8 | [
"Apache-2.0"
] | null | null | null | #include<iostream>
//array implementation of Queue-we will use a circular array
using namespace std;
int main() {
return 0;
}
| 11.909091 | 60 | 0.725191 | anjali9811 |
4b05bedfd2a86efddd6ce8365124b1de6e1667e8 | 3,503 | cpp | C++ | examples/julea/JuleaDAITest.cpp | julea-io/adios2 | c5b66294725eb7ff93827674f81a6a55241696a4 | [
"ECL-2.0",
"Apache-2.0"
] | 2 | 2019-07-12T11:57:03.000Z | 2020-05-14T09:40:01.000Z | examples/julea/JuleaDAITest.cpp | julea-io/adios2 | c5b66294725eb7ff93827674f81a6a55241696a4 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | examples/julea/JuleaDAITest.cpp | julea-io/adios2 | c5b66294725eb7ff93827674f81a6a55241696a4 | [
"ECL-2.0",
"Apache-2.0"
] | 1 | 2019-08-07T21:33:40.000Z | 2019-08-07T21:33:40.000Z | /*
* Distributed under the OSI-approved Apache License, Version 2.0. See
* accompanying file Copyright.txt for details.
*
* Created on: April 2022
* Author: Kira Duwe
*/
#include <chrono>
#include <ios> //std::ios_base::failure
#include <iostream> //std::cout
#include <stdexcept> //std::invalid_argument std::exception
#include <thread>
#include <vector>
#include <adios2.h>
#include <julea.h>
#include <julea-dai.h>
void TestDAISettings()
{
/** Application variable */
std::vector<float> myFloats = {12345.6, 1, 2, 3, 4, 5, 6, 7, 8, -42.333};
std::vector<int> myInts = {333, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const std::size_t Nx = myFloats.size();
const std::size_t Nx2 = myInts.size();
std::string fileName = "testFile.jb";
std::string varName = "juleaFloats";
std::string varName2 = "juleaInts";
// JDAIOperator compare = J_DAI_OP_GT;
// JDAIStatistic statistic = J_DAI_STAT_MAX;
// JDAITagGranularity granularity = J_DAI_TGRAN_BLOCK;
std::cout << "JuleaEngineTest Writing ... " << std::endl;
/** ADIOS class factory of IO class objects, DebugON is recommended */
adios2::ADIOS adios(adios2::DebugON);
/*** IO class object: settings and factory of Settings: Variables,
* Parameters, Transports, and Execution: Engines */
adios2::IO juleaIO = adios.DeclareIO("juleaIO");
// juleaIO.SetEngine("julea-kv");
juleaIO.SetEngine("julea-db-dai");
// juleaIO.SetEngine("julea-db");
/** global array: name, { shape (total dimensions) }, { start (local) },
* { count (local) }, all are constant dimensions */
adios2::Variable<float> juleaFloats = juleaIO.DefineVariable<float>(
varName, {Nx}, {0}, {Nx}, adios2::ConstantDims);
adios2::Variable<int> juleaInts = juleaIO.DefineVariable<int>(
varName2, {Nx2}, {0}, {Nx2}, adios2::ConstantDims);
/** Engine derived class, spawned to start IO operations */
adios2::Engine juleaWriter = juleaIO.Open(fileName, adios2::Mode::Write);
// This is probably when the DAI call should happen at latest. Maybe even at earliest
// j_dai_tag_feature_i(fileName, varName, "test_hot_days", J_DAI_STAT_MAX, 25, J_DAI_OP_GT, J_DAI_GRAN_BLOCK );
// j_dai_tag_feature_i(fileName, varName, "test_hot_days", statistic, 25, compare, granularity );
/** Write variable for buffering */
juleaWriter.Put<float>(juleaFloats, myFloats.data(), adios2::Mode::Deferred);
juleaWriter.Put<int>(juleaInts, myInts.data(), adios2::Mode::Deferred);
/** Create bp file, engine becomes unreachable after this*/
juleaWriter.Close();
}
int main(int argc, char *argv[])
{
/** Application variable */
std::vector<float> myFloats = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const std::size_t Nx = myFloats.size();
int err = -1;
try
{
std::cout << "JuleaDAITest :)" << std::endl;
TestDAISettings();
std::cout << "\n JuleaDAITest :) Write variable finished \n"
<< std::endl;
}
catch (std::invalid_argument &e)
{
std::cout << "Invalid argument exception, STOPPING PROGRAM\n";
std::cout << e.what() << "\n";
}
catch (std::ios_base::failure &e)
{
std::cout << "IO System base failure exception, STOPPING PROGRAM\n";
std::cout << e.what() << "\n";
}
catch (std::exception &e)
{
std::cout << "Exception, STOPPING PROGRAM\n";
std::cout << e.what() << "\n";
}
return 0;
}
| 32.137615 | 115 | 0.628319 | julea-io |
4b05f4fb18a96027c184f56aa1e37f2ad91aee1c | 7,362 | cc | C++ | serial/src/impl/list_ports/list_ports_linux.cc | chivstyle/comxd | d3eb006f866faf22cc8e1524afa0d99ae2049f79 | [
"MIT"
] | null | null | null | serial/src/impl/list_ports/list_ports_linux.cc | chivstyle/comxd | d3eb006f866faf22cc8e1524afa0d99ae2049f79 | [
"MIT"
] | null | null | null | serial/src/impl/list_ports/list_ports_linux.cc | chivstyle/comxd | d3eb006f866faf22cc8e1524afa0d99ae2049f79 | [
"MIT"
] | null | null | null | #if defined(__linux__)
/*
* Copyright (c) 2014 Craig Lilley <[email protected]>
* This software is made available under the terms of the MIT licence.
* A copy of the licence can be obtained from:
* http://opensource.org/licenses/MIT
*/
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
#include <glob.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "serial/serial.h"
using serial::PortInfo;
using std::cout;
using std::endl;
using std::getline;
using std::ifstream;
using std::istringstream;
using std::string;
using std::vector;
static vector<string> glob(const vector<string>& patterns);
static string basename(const string& path);
static string dirname(const string& path);
static bool path_exists(const string& path);
static string realpath(const string& path);
static string usb_sysfs_friendly_name(const string& sys_usb_path);
static vector<string> get_sysfs_info(const string& device_path);
static string read_line(const string& file);
static string usb_sysfs_hw_string(const string& sysfs_path);
static string format(const char* format, ...);
vector<string>
glob(const vector<string>& patterns)
{
vector<string> paths_found;
if (patterns.size() == 0)
return paths_found;
glob_t glob_results;
int glob_retval = glob(patterns[0].c_str(), 0, NULL, &glob_results);
vector<string>::const_iterator iter = patterns.begin();
while (++iter != patterns.end()) {
glob_retval = glob(iter->c_str(), GLOB_APPEND, NULL, &glob_results);
}
for (int path_index = 0; path_index < glob_results.gl_pathc; path_index++) {
paths_found.push_back(glob_results.gl_pathv[path_index]);
}
globfree(&glob_results);
return paths_found;
}
string
basename(const string& path)
{
size_t pos = path.rfind("/");
if (pos == std::string::npos)
return path;
return string(path, pos + 1, string::npos);
}
string
dirname(const string& path)
{
size_t pos = path.rfind("/");
if (pos == std::string::npos)
return path;
else if (pos == 0)
return "/";
return string(path, 0, pos);
}
bool path_exists(const string& path)
{
struct stat sb;
if (stat(path.c_str(), &sb) == 0)
return true;
return false;
}
string
realpath(const string& path)
{
char* real_path = realpath(path.c_str(), NULL);
string result;
if (real_path != NULL) {
result = real_path;
free(real_path);
}
return result;
}
string
usb_sysfs_friendly_name(const string& sys_usb_path)
{
unsigned int device_number = 0;
istringstream(read_line(sys_usb_path + "/devnum")) >> device_number;
string manufacturer = read_line(sys_usb_path + "/manufacturer");
string product = read_line(sys_usb_path + "/product");
string serial = read_line(sys_usb_path + "/serial");
if (manufacturer.empty() && product.empty() && serial.empty())
return "";
return format("%s %s %s", manufacturer.c_str(), product.c_str(), serial.c_str());
}
vector<string>
get_sysfs_info(const string& device_path)
{
string device_name = basename(device_path);
string friendly_name;
string hardware_id;
string sys_device_path = format("/sys/class/tty/%s/device", device_name.c_str());
if (device_name.compare(0, 6, "ttyUSB") == 0) {
sys_device_path = dirname(dirname(realpath(sys_device_path)));
if (path_exists(sys_device_path)) {
friendly_name = usb_sysfs_friendly_name(sys_device_path);
hardware_id = usb_sysfs_hw_string(sys_device_path);
}
} else if (device_name.compare(0, 6, "ttyACM") == 0) {
sys_device_path = dirname(realpath(sys_device_path));
if (path_exists(sys_device_path)) {
friendly_name = usb_sysfs_friendly_name(sys_device_path);
hardware_id = usb_sysfs_hw_string(sys_device_path);
}
} else {
// Try to read ID string of PCI device
string sys_id_path = sys_device_path + "/id";
if (path_exists(sys_id_path))
hardware_id = read_line(sys_id_path);
}
if (friendly_name.empty())
friendly_name = device_name;
if (hardware_id.empty())
hardware_id = "n/a";
vector<string> result;
result.push_back(friendly_name);
result.push_back(hardware_id);
return result;
}
string
read_line(const string& file)
{
ifstream ifs(file.c_str(), ifstream::in);
string line;
if (ifs) {
getline(ifs, line);
}
return line;
}
string
format(const char* format, ...)
{
va_list ap;
size_t buffer_size_bytes = 256;
string result;
char* buffer = (char*)malloc(buffer_size_bytes);
if (buffer == NULL)
return result;
bool done = false;
unsigned int loop_count = 0;
while (!done) {
va_start(ap, format);
int return_value = vsnprintf(buffer, buffer_size_bytes, format, ap);
if (return_value < 0) {
done = true;
} else if (return_value >= buffer_size_bytes) {
// Realloc and try again.
buffer_size_bytes = return_value + 1;
char* new_buffer_ptr = (char*)realloc(buffer, buffer_size_bytes);
if (new_buffer_ptr == NULL) {
done = true;
} else {
buffer = new_buffer_ptr;
}
} else {
result = buffer;
done = true;
}
va_end(ap);
if (++loop_count > 5)
done = true;
}
free(buffer);
return result;
}
string
usb_sysfs_hw_string(const string& sysfs_path)
{
string serial_number = read_line(sysfs_path + "/serial");
if (serial_number.length() > 0) {
serial_number = format("SNR=%s", serial_number.c_str());
}
string vid = read_line(sysfs_path + "/idVendor");
string pid = read_line(sysfs_path + "/idProduct");
return format("USB VID:PID=%s:%s %s", vid.c_str(), pid.c_str(), serial_number.c_str());
}
vector<PortInfo>
serial::list_ports()
{
vector<PortInfo> results;
vector<string> search_globs;
search_globs.push_back("/dev/ttyACM*");
search_globs.push_back("/dev/ttyS*");
search_globs.push_back("/dev/ttyUSB*");
search_globs.push_back("/dev/tty.*");
search_globs.push_back("/dev/cu.*");
vector<string> devices_found = glob(search_globs);
vector<string>::iterator iter = devices_found.begin();
while (iter != devices_found.end()) {
string device = *iter++;
vector<string> sysfs_info = get_sysfs_info(device);
string friendly_name = sysfs_info[0];
string hardware_id = sysfs_info[1];
PortInfo device_entry;
device_entry.port = device;
device_entry.description = friendly_name;
device_entry.hardware_id = hardware_id;
results.push_back(device_entry);
}
return results;
}
#endif // defined(__linux__)
| 23.596154 | 92 | 0.615865 | chivstyle |
4b09cbf6de41b540954fe244f3b39b633ee5b5c8 | 4,261 | cpp | C++ | src/modules/sound/lullaby/WaveDecoder.cpp | cigumo/love | 0b06d0d1f9defaef0353523012acf918cbc01954 | [
"Apache-2.0"
] | 2 | 2021-08-15T04:38:35.000Z | 2022-01-15T15:08:46.000Z | src/modules/sound/lullaby/WaveDecoder.cpp | cigumo/love | 0b06d0d1f9defaef0353523012acf918cbc01954 | [
"Apache-2.0"
] | 2 | 2019-02-27T07:12:48.000Z | 2019-11-28T10:04:36.000Z | src/modules/sound/lullaby/WaveDecoder.cpp | MikuAuahDark/livesim3-love | a893c17aa2c53fbe1843a18f744cb1c88142e6bb | [
"Apache-2.0"
] | 5 | 2020-09-04T21:49:38.000Z | 2022-03-14T20:48:02.000Z | /**
* Copyright (c) 2006-2020 LOVE Development Team
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
**/
#include "WaveDecoder.h"
#include <string.h>
#include "common/config.h"
#include "common/Exception.h"
namespace love
{
namespace sound
{
namespace lullaby
{
// Callbacks
static wuff_sint32 read_callback(void *userdata, wuff_uint8 *buffer, size_t *size)
{
WaveFile *input = (WaveFile *) userdata;
size_t bytes_left = input->size - input->offset;
size_t target_size = *size < bytes_left ? *size : bytes_left;
memcpy(buffer, input->data + input->offset, target_size);
input->offset += target_size;
*size = target_size;
return WUFF_SUCCESS;
}
static wuff_sint32 seek_callback(void *userdata, wuff_uint64 offset)
{
WaveFile *input = (WaveFile *)userdata;
input->offset = (size_t) (offset < input->size ? offset : input->size);
return WUFF_SUCCESS;
}
static wuff_sint32 tell_callback(void *userdata, wuff_uint64 *offset)
{
WaveFile *input = (WaveFile *)userdata;
*offset = input->offset;
return WUFF_SUCCESS;
}
wuff_callback WaveDecoderCallbacks = {read_callback, seek_callback, tell_callback};
WaveDecoder::WaveDecoder(Data *data, int bufferSize)
: Decoder(data, bufferSize)
{
dataFile.data = (char *) data->getData();
dataFile.size = data->getSize();
dataFile.offset = 0;
int wuff_status = wuff_open(&handle, &WaveDecoderCallbacks, &dataFile);
if (wuff_status < 0)
throw love::Exception("Could not open WAVE");
try
{
wuff_status = wuff_stream_info(handle, &info);
if (wuff_status < 0)
throw love::Exception("Could not retrieve WAVE stream info");
if (info.channels > 2)
throw love::Exception("Multichannel audio not supported");
if (info.format != WUFF_FORMAT_PCM_U8 && info.format != WUFF_FORMAT_PCM_S16)
{
wuff_status = wuff_format(handle, WUFF_FORMAT_PCM_S16);
if (wuff_status < 0)
throw love::Exception("Could not set output format");
}
}
catch (love::Exception &)
{
wuff_close(handle);
throw;
}
}
WaveDecoder::~WaveDecoder()
{
wuff_close(handle);
}
bool WaveDecoder::accepts(const std::string &ext)
{
static const std::string supported[] =
{
"wav", ""
};
for (int i = 0; !(supported[i].empty()); i++)
{
if (supported[i].compare(ext) == 0)
return true;
}
return false;
}
love::sound::Decoder *WaveDecoder::clone()
{
return new WaveDecoder(data.get(), bufferSize);
}
int WaveDecoder::decode()
{
size_t size = 0;
while (size < (size_t) bufferSize)
{
size_t bytes = bufferSize-size;
int wuff_status = wuff_read(handle, (wuff_uint8 *) buffer+size, &bytes);
if (wuff_status < 0)
return 0;
else if (bytes == 0)
{
eof = true;
break;
}
size += bytes;
}
return (int) size;
}
bool WaveDecoder::seek(double s)
{
int wuff_status = wuff_seek(handle, (wuff_uint64) (s * info.sample_rate));
if (wuff_status >= 0)
{
eof = false;
return true;
}
return false;
}
bool WaveDecoder::rewind()
{
int wuff_status = wuff_seek(handle, 0);
if (wuff_status >= 0)
{
eof = false;
return true;
}
return false;
}
bool WaveDecoder::isSeekable()
{
return true;
}
int WaveDecoder::getChannelCount() const
{
return info.channels;
}
int WaveDecoder::getBitDepth() const
{
return info.bits_per_sample == 8 ? 8 : 16;
}
int WaveDecoder::getSampleRate() const
{
return info.sample_rate;
}
double WaveDecoder::getDuration()
{
return (double) info.length / (double) info.sample_rate;
}
} // lullaby
} // sound
} // love
| 21.305 | 83 | 0.702183 | cigumo |
4b10879d607c082f4f11431c50ab152b6d8c920e | 1,534 | cpp | C++ | smacc2_sm_reference_library/sm_dance_bot_lite/src/sm_dance_bot_lite/clients/cl_led/cl_led.cpp | reelrbtx/SMACC2 | ac61cb1599f215fd9f0927247596796fc53f82bf | [
"Apache-2.0"
] | null | null | null | smacc2_sm_reference_library/sm_dance_bot_lite/src/sm_dance_bot_lite/clients/cl_led/cl_led.cpp | reelrbtx/SMACC2 | ac61cb1599f215fd9f0927247596796fc53f82bf | [
"Apache-2.0"
] | null | null | null | smacc2_sm_reference_library/sm_dance_bot_lite/src/sm_dance_bot_lite/clients/cl_led/cl_led.cpp | reelrbtx/SMACC2 | ac61cb1599f215fd9f0927247596796fc53f82bf | [
"Apache-2.0"
] | null | null | null | // Copyright 2021 RobosoftAI 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.
/*****************************************************************************************************************
*
* Authors: Pablo Inigo Blasco, Brett Aldrich
*
******************************************************************************************************************/
#include <sm_dance_bot_lite/clients/cl_led/cl_led.hpp>
//#include <pluginlib/class_list_macros.h>
namespace sm_dance_bot_lite
{
namespace cl_led
{
ClLED::ClLED(std::string actionServerName)
: SmaccActionClientBase<sm_dance_bot_lite::action::LEDControl>(actionServerName)
{
}
std::string ClLED::getName() const { return "TOOL ACTION CLIENT"; }
ClLED::~ClLED() {}
std::ostream & operator<<(
std::ostream & out, const sm_dance_bot_lite::action::LEDControl::Goal & msg)
{
out << "LED CONTROL: " << msg.command;
return out;
}
} // namespace cl_led
//PLUGINLIB_EXPORT_CLASS(cl_led::ClLED, smacc2::ISmaccComponent)
} // namespace sm_dance_bot_lite
| 32.638298 | 116 | 0.628422 | reelrbtx |
4b116cc97c32f19ae5ae9ff450e452c30eb93242 | 5,147 | cpp | C++ | Rumble3D/src/RigidBodyEngine/BVHNode.cpp | Nelaty/Rumble3D | 801b9feec27ceeea91db3b759083f6351634e062 | [
"MIT"
] | 1 | 2020-01-21T16:01:53.000Z | 2020-01-21T16:01:53.000Z | Rumble3D/src/RigidBodyEngine/BVHNode.cpp | Nelaty/Rumble3D | 801b9feec27ceeea91db3b759083f6351634e062 | [
"MIT"
] | 1 | 2019-10-08T08:25:33.000Z | 2019-10-09T06:39:06.000Z | Rumble3D/src/RigidBodyEngine/BVHNode.cpp | Nelaty/Rumble3D | 801b9feec27ceeea91db3b759083f6351634e062 | [
"MIT"
] | 1 | 2019-05-14T13:48:16.000Z | 2019-05-14T13:48:16.000Z | #include "R3D/RigidBodyEngine/BVHNode.h"
#include "R3D/RigidBodyEngine/BoundingSphere.h"
#include "R3D/RigidBodyEngine/BoundingBox.h"
#include "R3D/RigidBodyEngine/RigidBody.h"
namespace r3
{
namespace
{
template<class T>
class has_overlap_method
{
template<typename U, bool (U::*)(const U*) const> struct checker {};
template<typename U> static char test(checker<U, &U::overlap>*);
template<typename U> static int test(...);
public:
static const bool value = sizeof(test<T>(nullptr)) == sizeof(char);
};
}
template<class BoundingVolumeClass>
BVHNode<BoundingVolumeClass>::BVHNode(BVHNode<BoundingVolumeClass>* parent,
const BoundingVolumeClass& volume,
RigidBody* body)
: m_parent(parent),
m_body(body),
m_volume(volume)
{
//static_assert(has_overlap_method<BoundingVolumeClass>::value,
// "Bounding volume class doens't support overlap method!");
}
template<class BoundingVolumeClass>
BVHNode<BoundingVolumeClass>::~BVHNode()
{
auto* sibling = getSibling();
if(sibling)
{
// �berschreibe Elternknoten mit Geschwisterdaten
m_parent->m_volume = sibling->m_volume;
m_parent->m_body = sibling->m_body;
m_parent->m_children[0] = sibling->m_children[0];
m_parent->m_children[1] = sibling->m_children[1];
// L�sche das urspr�nglicheGeschwisterojekt.
sibling->m_parent = nullptr;
sibling->m_body = nullptr;
sibling->m_children[0] = nullptr;
sibling->m_children[1] = nullptr;
delete sibling;
// Eltern Volumen neu berechnen:
m_parent->recalculateBoundingVolume();
}
// L�sche Kinder.
if(m_children[0])
{
m_children[0]->m_parent = nullptr;
delete m_children[0];
}
if(m_children[1])
{
m_children[1]->m_parent = nullptr;
delete m_children[1];
}
}
template<class BoundingVolumeClass>
bool BVHNode<BoundingVolumeClass>::isLeaf() const
{
return m_body != nullptr;
}
template<class BoundingVolumeClass>
void BVHNode<BoundingVolumeClass>::getPotentialContacts(FixedSizeContainer<CollisionPair>& contacts) const
{
if(isLeaf() || contacts.isFull())
{
return;
}
// Potentielle Kontakte eines unserer Kinder mit dem anderen.
m_children[0]->getPotentialContactsWith(m_children[1], contacts);
}
template <class BoundingVolumeClass>
BVHNode<BoundingVolumeClass>* BVHNode<BoundingVolumeClass>::getSibling() const
{
if(!m_parent)
{
return nullptr;
}
if (this == m_parent->m_children[0])
{
return m_parent->m_children[1];
}
return m_parent->m_children[0];
}
template<class BoundingVolumeClass>
bool BVHNode<BoundingVolumeClass>::overlaps(BVHNode<BoundingVolumeClass> * other) const
{
return m_volume.overlaps(&(other->m_volume));
}
template<class BoundingVolumeClass>
void BVHNode<BoundingVolumeClass>::getPotentialContactsWith(BVHNode<BoundingVolumeClass>* other,
FixedSizeContainer<CollisionPair>& contacts) const
{
if(!overlaps(other) || contacts.isFull()) return;
/** Potential contact if both are leaf nodes. */
if(isLeaf() && other->isLeaf())
{
auto entry = contacts.getAvailableEntry();
entry->init(m_body, other->m_body);
return;
}
/** Recursively get potential contacts with child nodes. */
if(other->isLeaf() ||
(!isLeaf() && m_volume.getVolume() >= other->m_volume.getVolume()))
{
m_children[0]->getPotentialContactsWith(other, contacts);
m_children[1]->getPotentialContactsWith(other, contacts);
return;
}
getPotentialContactsWith(other->m_children[0], contacts);
getPotentialContactsWith(other->m_children[1], contacts);
}
template<class BoundingVolumeClass>
void BVHNode<BoundingVolumeClass>::recalculateBoundingVolume()
{
if(isLeaf()) return;
m_volume = BoundingVolumeClass(m_children[0]->m_volume,
m_children[1]->m_volume);
if(m_parent)
{
m_parent->recalculateBoundingVolume();
}
}
template<class BoundingVolumeClass>
void BVHNode<BoundingVolumeClass>::insert(RigidBody* newBody,
const BoundingVolumeClass &newVolume)
{
// Wenn this ein Blatt ist, brauchen wir zwei Kinder, eines
// mit this und das andere mit newBody
if(isLeaf())
{
// Kopie von this in Kind_0.
m_children[0] = new BVHNode<BoundingVolumeClass>(this, m_volume, m_body);
// Kind2 ist neuer Festk�rper
m_children[1] = new BVHNode<BoundingVolumeClass>(this, newVolume, newBody);
// And we now loose the body (we're no longer a leaf)
m_body = nullptr;
recalculateBoundingVolume();
}
// F�ge neuen Festk�rper dort ein, wo resultierendes Volumen
// am kleinsten ist:
else
{
if(m_children[0]->m_volume.getGrowth(newVolume) <
m_children[1]->m_volume.getGrowth(newVolume))
{
m_children[0]->insert(newBody, newVolume);
}
else
{
m_children[1]->insert(newBody, newVolume);
}
}
}
// Widerspricht dem Template-Konzept, sorgt jedoch f�r
// Information Hiding der Implementierung. Es d�rfen seitens
// der Nutzer der Klasse lediglich Instanzen mit aktuellem
// Klassenparameter BoundingSphere gebildet werden.
template class BVHNode<BoundingSphere>;
template class BVHNode<BoundingBox>;
} | 26.530928 | 107 | 0.710122 | Nelaty |
4b121fb6ad2b01dc0bcfc102f7f292b2b54e12d2 | 17,031 | cc | C++ | Client/ServerControl.cc | dymons/logcabin | 185c81c0eca3a8e92826389cf5ca289d81045869 | [
"ISC"
] | null | null | null | Client/ServerControl.cc | dymons/logcabin | 185c81c0eca3a8e92826389cf5ca289d81045869 | [
"ISC"
] | null | null | null | Client/ServerControl.cc | dymons/logcabin | 185c81c0eca3a8e92826389cf5ca289d81045869 | [
"ISC"
] | null | null | null | /* Copyright (c) 2015 Diego Ongaro
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <cassert>
#include <getopt.h>
#include <iostream>
#include <string>
#include <vector>
#include "Client/ClientImpl.h"
#include "Core/ProtoBuf.h"
#include "ServerControl.pb.h"
#include "include/LogCabin/Client.h"
#include "include/LogCabin/Debug.h"
#include "include/LogCabin/Util.h"
namespace LogCabin {
namespace Client {
namespace {
using Client::Util::parseNonNegativeDuration;
/**
* Parses argv for the main function.
*/
class OptionParser {
public:
OptionParser(int& argc, char**& argv)
: argc(argc)
, argv(argv)
, args()
, lastIndex(0)
, logPolicy("")
, server("localhost:5254")
, timeout(parseNonNegativeDuration("0s"))
{
while (true) {
static struct option longOptions[] = {
{"help", no_argument, NULL, 'h'},
{"server", required_argument, NULL, 's'},
{"timeout", required_argument, NULL, 't'},
{"verbose", no_argument, NULL, 'v'},
{"verbosity", required_argument, NULL, 256},
{0, 0, 0, 0}
};
int c = getopt_long(argc, argv, "s:t:hv", longOptions, NULL);
// Detect the end of the options.
if (c == -1)
break;
switch (c) {
case 'h':
usage();
exit(0);
case 's':
server = optarg;
break;
case 't':
timeout = parseNonNegativeDuration(optarg);
break;
case 'v':
logPolicy = "VERBOSE";
break;
case 256:
logPolicy = optarg;
break;
case '?':
default:
// getopt_long already printed an error message.
usage();
exit(1);
}
}
args.assign(&argv[optind], &argv[argc]);
}
/**
* Return the positional argument at the given index,
* or panic if there were not enough arguments.
*/
std::string at(uint64_t index) {
if (args.size() <= index)
usageError("Missing arguments");
lastIndex = index;
return args.at(index);
}
/**
* Return all arguments at index or following it.
*/
std::string remaining(uint64_t index) {
lastIndex = args.size();
std::string r;
while (index < args.size()) {
r += args.at(index);
if (index < args.size() - 1)
r += " ";
++index;
}
if (index < args.size())
r += args.at(index);
return r;
}
/**
* Panic if are any unused arguments remain.
*/
void done() {
if (args.size() > lastIndex + 1)
usageError("Too many arguments");
}
/**
* Print an error and the usage message and exit nonzero.
*/
void usageError(const std::string& message) {
std::cerr << message << std::endl;
usage();
exit(1);
}
/**
* Helper for spacing in usage() message.
*/
std::string ospace(std::string option) {
std::string after;
if (option.size() < 31 - 2)
after = std::string(31 - 2 - option.size(), ' ');
return " " + option + after;
}
void usage() {
std::cout << "Inspect or modify the state of a single LogCabin server."
<< std::endl
<< std::endl
<< "This program was added in LogCabin v1.1.0."
<< std::endl;
std::cout << std::endl;
std::cout << "Usage: " << argv[0] << " [options] <command> [<args>]"
<< std::endl;
std::cout << std::endl;
std::string space(31, ' ');
std::cout << "Commands:" << std::endl;
std::cout
<< ospace("info get")
<< "Print server ID and addresses."
<< std::endl
<< ospace("debug filename get")
<< "Print the server's debug log filename."
<< std::endl
<< ospace("debug filename set <path>")
<< "Change the server's debug log filename."
<< std::endl
<< ospace("debug policy get")
<< "Print the server's debug log policy."
<< std::endl
<< ospace("debug policy set <value>")
<< "Change the server's debug log policy."
<< std::endl
<< ospace("debug rotate")
<< "Rotate the server's debug log file."
<< std::endl
<< ospace("snapshot inhibit get")
<< "Print the remaining time for which the server"
<< std::endl << space
<< "was prevented from taking snapshots."
<< std::endl
<< ospace("snapshot inhibit set [<time>]")
<< " Abort the server's current snapshot if one is"
<< std::endl << space
<< " in progress, and disallow the server from"
<< std::endl << space
<< " starting automated snapshots for the given"
<< std::endl << space
<< " duration [default: 1week]."
<< std::endl
<< ospace("snapshot inhibit clear")
<< "Allow the server to take snapshots normally."
<< std::endl
<< ospace("snapshot start")
<< "Begin taking a snapshot if none is in progress."
<< std::endl
<< ospace("snapshot stop")
<< "Abort the current snapshot if one is in"
<< std::endl << space
<< "progress."
<< std::endl
<< ospace("snapshot restart")
<< "Abort the current snapshot if one is in"
<< std::endl << space
<< "progress, then begin taking a new snapshot."
<< std::endl
<< ospace("stats get")
<< "Print detailed server metrics."
<< std::endl
<< ospace("stats dump")
<< "Write detailed server metrics to server's debug"
<< std::endl << space
<< "log."
<< std::endl
<< std::endl;
std::cout << "Options:" << std::endl;
std::cout
<< ospace("-h, --help")
<< "Print this usage information and exit"
<< std::endl
<< " -s <addresses>, --server=<addresses> "
<< "Network addresses of the target"
<< std::endl
<< " "
<< "LogCabin server, comma-separated"
<< std::endl
<< " "
<< "[default: localhost:5254]"
<< std::endl
<< ospace("-t <time>, --timeout=<time>")
<< "Set timeout for the operation"
<< std::endl << space
<< "(0 means wait forever) [default: 0s]"
<< std::endl
<< ospace("-v, --verbose")
<< "Same as --verbosity=VERBOSE"
<< std::endl
<< ospace("--verbosity=<policy>")
<< "Set which log messages are shown."
<< std::endl << space
<< "Comma-separated LEVEL or PATTERN@LEVEL rules."
<< std::endl << space
<< "Levels: SILENT, ERROR, WARNING, NOTICE, VERBOSE."
<< std::endl << space
<< "Patterns match filename prefixes or suffixes."
<< std::endl << space
<< "Example: Client@NOTICE,Test.cc@SILENT,VERBOSE."
<< std::endl;
// TODO(ongaro): human-readable vs machine-readable output?
}
int& argc;
char**& argv;
std::vector<std::string> args;
uint64_t lastIndex;
std::string logPolicy;
std::string server;
uint64_t timeout;
};
/**
* Print an error message and exit nonzero.
*/
void
error(const std::string& message)
{
std::cerr << "Error: " << message << std::endl;
exit(1);
}
namespace Proto = Protocol::ServerControl;
/**
* Wrapper for invoking ServerControl RPCs.
*/
class ServerControl {
public:
ServerControl(const std::string& server, ClientImpl::TimePoint timeout)
: clientImpl()
, server(server)
, timeout(timeout)
{
clientImpl.init("-INVALID-"); // shouldn't attempt to connect to this
}
#define DEFINE_RPC(type, opcode) \
void type(const Proto::type::Request& request, \
Proto::type::Response& response) { \
Result result = clientImpl.serverControl( \
server, \
timeout, \
Proto::OpCode::opcode, \
request, response); \
if (result.status != Status::OK) { \
error(result.error); \
} \
}
DEFINE_RPC(DebugFilenameGet, DEBUG_FILENAME_GET)
DEFINE_RPC(DebugFilenameSet, DEBUG_FILENAME_SET)
DEFINE_RPC(DebugPolicyGet, DEBUG_POLICY_GET)
DEFINE_RPC(DebugPolicySet, DEBUG_POLICY_SET)
DEFINE_RPC(DebugRotate, DEBUG_ROTATE)
DEFINE_RPC(ServerInfoGet, SERVER_INFO_GET)
DEFINE_RPC(ServerStatsDump, SERVER_STATS_DUMP)
DEFINE_RPC(ServerStatsGet, SERVER_STATS_GET)
DEFINE_RPC(SnapshotControl, SNAPSHOT_CONTROL)
DEFINE_RPC(SnapshotInhibitGet, SNAPSHOT_INHIBIT_GET)
DEFINE_RPC(SnapshotInhibitSet, SNAPSHOT_INHIBIT_SET)
#undef DEFINE_RPC
void snapshotControl(Proto::SnapshotCommand command) {
Proto::SnapshotControl::Request request;
Proto::SnapshotControl::Response response;
request.set_command(command);
SnapshotControl(request, response);
if (response.has_error())
error(response.error());
}
ClientImpl clientImpl;
std::string server;
ClientImpl::TimePoint timeout;
};
} // namespace LogCabin::Client::<anonymous>
} // namespace LogCabin::Client
} // namespace LogCabin
int
main(int argc, char** argv)
{
using namespace LogCabin;
using namespace LogCabin::Client;
using Core::ProtoBuf::dumpString;
try {
Client::OptionParser options(argc, argv);
Client::Debug::setLogPolicy(
Client::Debug::logPolicyFromString(options.logPolicy));
ServerControl server(options.server,
ClientImpl::absTimeout(options.timeout));
if (options.at(0) == "info") {
if (options.at(1) == "get") {
options.done();
Proto::ServerInfoGet::Request request;
Proto::ServerInfoGet::Response response;
server.ServerInfoGet(request, response);
std::cout << dumpString(response);
return 0;
}
} else if (options.at(0) == "debug") {
if (options.at(1) == "filename") {
if (options.at(2) == "get") {
options.done();
Proto::DebugFilenameGet::Request request;
Proto::DebugFilenameGet::Response response;
server.DebugFilenameGet(request, response);
std::cout << response.filename() << std::endl;
return 0;
} else if (options.at(2) == "set") {
std::string value = options.at(3);
options.done();
Proto::DebugFilenameSet::Request request;
Proto::DebugFilenameSet::Response response;
request.set_filename(value);
server.DebugFilenameSet(request, response);
if (response.has_error())
error(response.error());
return 0;
}
} else if (options.at(1) == "policy") {
if (options.at(2) == "get") {
options.done();
Proto::DebugPolicyGet::Request request;
Proto::DebugPolicyGet::Response response;
server.DebugPolicyGet(request, response);
std::cout << response.policy() << std::endl;
return 0;
} else if (options.at(2) == "set") {
std::string value = options.at(3);
options.done();
Proto::DebugPolicySet::Request request;
Proto::DebugPolicySet::Response response;
request.set_policy(value);
server.DebugPolicySet(request, response);
return 0;
}
} else if (options.at(1) == "rotate") {
options.done();
Proto::DebugRotate::Request request;
Proto::DebugRotate::Response response;
server.DebugRotate(request, response);
if (response.has_error())
error(response.error());
return 0;
}
} else if (options.at(0) == "snapshot") {
using Proto::SnapshotCommand;
if (options.at(1) == "start") {
options.done();
server.snapshotControl(SnapshotCommand::START_SNAPSHOT);
return 0;
} else if (options.at(1) == "stop") {
options.done();
server.snapshotControl(SnapshotCommand::STOP_SNAPSHOT);
return 0;
} else if (options.at(1) == "restart") {
options.done();
server.snapshotControl(SnapshotCommand::RESTART_SNAPSHOT);
return 0;
} else if (options.at(1) == "inhibit") {
if (options.at(2) == "get") {
options.done();
Proto::SnapshotInhibitGet::Request request;
Proto::SnapshotInhibitGet::Response response;
server.SnapshotInhibitGet(request, response);
std::chrono::nanoseconds ns(response.nanoseconds());
std::cout << ns << std::endl;
return 0;
} else if (options.at(2) == "set") {
Proto::SnapshotInhibitSet::Request request;
std::string time = options.remaining(3);
if (time.empty())
time = "1week";
request.set_nanoseconds(parseNonNegativeDuration(time));
Proto::SnapshotInhibitSet::Response response;
server.SnapshotInhibitSet(request, response);
if (response.has_error())
error(response.error());
return 0;
} else if (options.at(2) == "clear") {
options.done();
Proto::SnapshotInhibitSet::Request request;
request.set_nanoseconds(0);
Proto::SnapshotInhibitSet::Response response;
server.SnapshotInhibitSet(request, response);
if (response.has_error())
error(response.error());
return 0;
}
}
} else if (options.at(0) == "stats") {
if (options.at(1) == "get") {
options.done();
Proto::ServerStatsGet::Request request;
Proto::ServerStatsGet::Response response;
server.ServerStatsGet(request, response);
std::cout << dumpString(response.server_stats());
return 0;
} else if (options.at(1) == "dump") {
options.done();
Proto::ServerStatsDump::Request request;
Proto::ServerStatsDump::Response response;
server.ServerStatsDump(request, response);
return 0;
}
}
options.usageError("Unknown command");
} catch (const LogCabin::Client::Exception& e) {
std::cerr << "Exiting due to LogCabin::Client::Exception: "
<< e.what()
<< std::endl;
exit(1);
}
}
| 34.615854 | 79 | 0.503494 | dymons |
4b147624130efe385ab844761baa70cf052bc80c | 102,980 | cpp | C++ | tests/universalidentifier_tests.cpp | italocoin-project/bittube-light-wallet | 66386ace27df39bf11ca70327fbdf5865f2c610e | [
"BSD-3-Clause"
] | null | null | null | tests/universalidentifier_tests.cpp | italocoin-project/bittube-light-wallet | 66386ace27df39bf11ca70327fbdf5865f2c610e | [
"BSD-3-Clause"
] | null | null | null | tests/universalidentifier_tests.cpp | italocoin-project/bittube-light-wallet | 66386ace27df39bf11ca70327fbdf5865f2c610e | [
"BSD-3-Clause"
] | null | null | null | #include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "../src/UniversalIdentifier.hpp"
#include "mocks.h"
#include "helpers.h"
namespace
{
using namespace xmreg;
//string addr_56Vbjcz {"56VbjczrFCVZiLn66S3Qzv8QfmtcwkdXgM5cWGsXAPxoQeMQ79md51PLPCijvzk1iHbuHi91pws5B7iajTX9KTtJ4Z6HAo6"};
//string viewkey_56Vbjcz {"f747f4a4838027c9af80e6364a941b60c538e67e9ea198b6ec452b74c276de06"};
//string spendkey_56Vbjcz {"509a9761fde8856fc38e79ca705d85f979143524f178f8e2e0eb539fc050e905"};
//// ./xmr2csv --stagenet -b /home/mwo/stagenet/node_01/stagenet/lmdb/ -a 56VbjczrFCVZiLn66S3Qzv8QfmtcwkdXgM5cWGsXAPxoQeMQ79md51PLPCijvzk1iHbuHi91pws5B7iajTX9KTtJ4Z6HAo6 -v f747f4a4838027c9af80e6364a941b60c538e67e9ea198b6ec452b74c276de06
//string known_outputs_csv_2_56bCoE {"./res/outputs_stagenet_2_56Vbjcz.csv"};
inline bool
operator==(const Output::info& lhs, const JsonTx::output& rhs)
{
return lhs.amount == rhs.amount
&& lhs.pub_key == rhs.pub_key
&& lhs.idx_in_tx == rhs.index;
}
inline bool
operator!=(const Output::info& lhs, const JsonTx::output& rhs)
{
return !(lhs == rhs);
}
inline bool
operator==(const vector<Output::info>& lhs, const vector<JsonTx::output>& rhs)
{
if (lhs.size() != rhs.size())
return false;
for (size_t i = 0; i < lhs.size(); i++)
{
if (lhs[i] != rhs[i])
return false;
}
return true;
}
TEST(MODULAR_IDENTIFIER, OutputsRingCT)
{
auto jtx = construct_jsontx("ddff95211b53c194a16c2b8f37ae44b643b8bd46b4cb402af961ecabeb8417b2");
ASSERT_TRUE(jtx);
auto identifier = make_identifier(jtx->tx,
make_unique<Output>(&jtx->sender.address,
&jtx->sender.viewkey));
identifier.identify();
ASSERT_EQ(identifier.get<0>()->get().size(),
jtx->sender.outputs.size());
ASSERT_TRUE(identifier.get<0>()->get() == jtx->sender.outputs);
ASSERT_EQ(identifier.get<0>()->get_total(),
jtx->sender.change);
}
TEST(MODULAR_IDENTIFIER, OutputsRingCTCoinbaseTx)
{
auto jtx = construct_jsontx("f3c84fe925292ec5b4dc383d306d934214f4819611566051bca904d1cf4efceb");
ASSERT_TRUE(jtx);
auto identifier = make_identifier(jtx->tx,
make_unique<Output>(&jtx->recipients.at(0).address,
&jtx->recipients.at(0).viewkey));
identifier.identify();
ASSERT_TRUE(identifier.get<0>()->get()
== jtx->recipients.at(0).outputs);
ASSERT_EQ(identifier.get<0>()->get_total(),
jtx->recipients.at(0).amount);
}
TEST(MODULAR_IDENTIFIER, MultiOutputsRingCT)
{
auto jtx = construct_jsontx("d7dcb2daa64b5718dad71778112d48ad62f4d5f54337037c420cb76efdd8a21c");
ASSERT_TRUE(jtx);
for (auto const& jrecipient: jtx->recipients)
{
auto identifier = make_identifier(jtx->tx,
make_unique<Output>(&jrecipient.address,
&jrecipient.viewkey));
identifier.identify();
EXPECT_TRUE(identifier.get<0>()->get()
== jrecipient.outputs);
}
}
TEST(MODULAR_IDENTIFIER, LegacyPaymentID)
{
auto jtx = construct_jsontx("d7dcb2daa64b5718dad71778112d48ad62f4d5f54337037c420cb76efdd8a21c");
ASSERT_TRUE(jtx);
auto identifier = make_identifier(jtx->tx,
make_unique<LegacyPaymentID>(nullptr, nullptr));
identifier.identify();
EXPECT_TRUE(identifier.get<0>()->get()
== jtx->payment_id);
}
TEST(MODULAR_IDENTIFIER, IntegratedPaymentID)
{
auto jtx = construct_jsontx("ddff95211b53c194a16c2b8f37ae44b643b8bd46b4cb402af961ecabeb8417b2");
ASSERT_TRUE(jtx);
auto identifier = make_identifier(jtx->tx,
make_unique<IntegratedPaymentID>(
&jtx->recipients[0].address,
&jtx->recipients[0].viewkey));
identifier.identify();
EXPECT_TRUE(identifier.get<0>()->get()
== jtx->payment_id8e);
}
TEST(MODULAR_IDENTIFIER, RealInputRingCT)
{
auto jtx = construct_jsontx("d7dcb2daa64b5718dad71778112d48ad62f4d5f54337037c420cb76efdd8a21c");
ASSERT_TRUE(jtx);
MockMicroCore mcore;
EXPECT_CALL(mcore, get_output_tx_and_index(_, _, _))
.WillRepeatedly(
Invoke(&*jtx, &JsonTx::get_output_tx_and_index));
EXPECT_CALL(mcore, get_tx(_, _))
.WillRepeatedly(
Invoke(&*jtx, &JsonTx::get_tx));
auto identifier = make_identifier(jtx->tx,
make_unique<RealInput>(
&jtx->sender.address,
&jtx->sender.viewkey,
&jtx->sender.spendkey,
&mcore));
identifier.identify();
for (auto const& input_info: identifier.get<0>()->get())
cout << input_info << endl;
EXPECT_TRUE(identifier.get<0>()->get().size() == 2);
}
//// private testnet wallet 9wq792k9sxVZiLn66S3Qzv8QfmtcwkdXgM5cWGsXAPxoQeMQ79md51PLPCijvzk1iHbuHi91pws5B7iajTX9KTtJ4bh2tCh
//// viewkey f747f4a4838027c9af80e6364a941b60c538e67e9ea198b6ec452b74c276de06
//// spendkey 509a9761fde8856fc38e79ca705d85f979143524f178f8e2e0eb539fc050e905
//// seed: deftly large tirade gumball android leech sidekick opened iguana voice gels focus poaching itches network espionage much jailed vaults winter oatmeal eleven science siren winter
//string addr_9wq792k {"9wq792k9sxVZiLn66S3Qzv8QfmtcwkdXgM5cWGsXAPxoQeMQ79md51PLPCijvzk1iHbuHi91pws5B7iajTX9KTtJ4bh2tCh"};
//string viewkey_9wq792k {"f747f4a4838027c9af80e6364a941b60c538e67e9ea198b6ec452b74c276de06"};
//string spendkey_9wq792k {"509a9761fde8856fc38e79ca705d85f979143524f178f8e2e0eb539fc050e905"};
//// ./xmr2csv --testnet -b /home/mwo/testnet/node_01/testnet/lmdb/ -a 9wq792k9sxVZiLn66S3Qzv8QfmtcwkdXgM5cWGsXAPxoQeMQ79md51PLPCijvzk1iHbuHi91pws5B7iajTX9KTtJ4bh2tCh -v f747f4a4838027c9af80e6364a941b60c538e67e9ea198b6ec452b74c276de06
//string known_outputs_csv_9wq792k {"./res/outputs_testnet_9wq792k9.csv"};
//TEST(MODULAR_IDENTIFIER, IncomingPreRingctTransaction)
//{
// // private testnet tx_hash 01e3d29a5b6b6e1999b9e7e48b9abe101bb93055b701b23d98513fb0646e7570
// // the tx has only one output for 10 xmr, so we check
// // if we can identify it.
// string tx_hex {"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"};
// TX_AND_ADDR_VIEWKEY_FROM_STRING(tx_hex, addr_9wq792k, viewkey_9wq792k,
// network_type::TESTNET);
// auto identifier = make_identifier(tx,
// make_unique<Output>(&address, &viewkey));
// identifier.identify();
// ASSERT_EQ(identifier.get<Output>()->get().size(), 1);
// ASSERT_EQ(identifier.get<Output>()->get_total(), 10000000000000);
//}
//TEST(MODULAR_IDENTIFIER, OutgingPreRingctTransaction)
//{
// // private testnet tx_hash 0889658a54ddfaa61f62fdc0393adc498e1227195d413de45c5f0e0da3f5068d
// // the tx has only one output for 10 xmr, so we check
// // if we can identify it.
// string tx_hex {"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"};
// TX_AND_ADDR_VIEWKEY_FROM_STRING(tx_hex, addr_9wq792k, viewkey_9wq792k,
// network_type::TESTNET);
// SPENDKEY_FROM_STRING(spendkey_9wq792k);
// string ring_member_data_hex {"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"};
// GET_RING_MEMBER_OUTPUTS(ring_member_data_hex);
// GET_KNOWN_OUTPUTS(known_outputs_csv_9wq792k);
// MOCK_MCORE_GET_OUTPUT_KEY();
// auto identifier = make_identifier(tx,
// make_unique<Input>(&address, &viewkey,
// &known_outputs, mcore.get()),
// make_unique<RealInput>(&address, &viewkey,
// &spendkey, mcore.get())
// );
// identifier.identify();
// ASSERT_EQ(identifier.get<Input>()->get().size(), 2);
// ASSERT_EQ(identifier.get<Input>()->get_total(), 17000000000000ull);
// ASSERT_EQ(identifier.get<RealInput>()->get().size(), 2);
// ASSERT_EQ(identifier.get<RealInput>()->get_total(), 17000000000000ull);
//}
//TEST(MODULAR_IDENTIFIER, DefaultConstruction)
//{
// string tx_hex {"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"};
// TX_AND_ADDR_VIEWKEY_FROM_STRING(tx_hex, addr_56Vbjcz, viewkey_56Vbjcz,
// network_type::STAGENET);
// GET_KNOWN_OUTPUTS(known_outputs_csv_2_56bCoE);
// // the ring members data from the above tx
// //
// // this hex is obtained using onion explorer runnign with --enbale-as-hex flag
// // it is hex, serializied representation of of map of key_images
// // with corresponding ring members output_data_t info structure
// // we do this so that we just mack all the calls, instead of
// // accessing real blockchain for this data.
// string ring_member_data_hex {"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"};
// GET_RING_MEMBER_OUTPUTS(ring_member_data_hex);
// MOCK_MCORE_GET_OUTPUT_KEY();
// std::cout << "\n\n" << std::endl;
// auto identifier = make_identifier(tx,
// make_unique<Output>(&address, &viewkey),
// make_unique<Input>(&address, &viewkey, &known_outputs,
// mcore.get()),
// make_unique<LegacyPaymentID>(&address, &viewkey),
// make_unique<IntegratedPaymentID>(&address, &viewkey));
// identifier.identify();
// ASSERT_EQ(identifier.get<Output>()->get().size(), 1);
// std::cout << "\n\n" << std::endl;
//}
}
| 360.06993 | 44,447 | 0.971286 | italocoin-project |
4b19c9a8c964125c1cc1bbdde07b07a6d1544c2e | 7,368 | cpp | C++ | BaseAudioDriver/Source/Utilities/hw.cpp | nicsor/DiskJunkey | cfbaeb555f1e42fc8473f43328cea1fda929dc30 | [
"MIT"
] | 1 | 2021-08-04T08:40:43.000Z | 2021-08-04T08:40:43.000Z | BaseAudioDriver/Source/Utilities/hw.cpp | nicsor/DiskJunkey | cfbaeb555f1e42fc8473f43328cea1fda929dc30 | [
"MIT"
] | 2 | 2021-08-03T14:42:38.000Z | 2021-09-08T08:31:58.000Z | BaseAudioDriver/Source/Utilities/hw.cpp | nicsor/DiskJunkey | cfbaeb555f1e42fc8473f43328cea1fda929dc30 | [
"MIT"
] | 1 | 2021-12-14T10:19:09.000Z | 2021-12-14T10:19:09.000Z | /*++
Copyright (c) Microsoft Corporation All Rights Reserved
Module Name:
hw.cpp
Abstract:
Implementation of Base Audio Driver HW class.
Base Audio Driver HW has an array for storing mixer and volume settings
for the topology.
--*/
#include "definitions.h"
#include "hw.h"
//=============================================================================
// CBaseAudioDriverHW
//=============================================================================
//=============================================================================
#pragma code_seg("PAGE")
CBaseAudioDriverHW::CBaseAudioDriverHW()
: m_ulMux(0),
m_bDevSpecific(FALSE),
m_iDevSpecific(0),
m_uiDevSpecific(0)
/*++
Routine Description:
Constructor for BaseAudioDriverHW.
Arguments:
Return Value:
void
--*/
{
PAGED_CODE();
MixerReset();
} // BaseAudioDriverHW
#pragma code_seg()
//=============================================================================
BOOL
CBaseAudioDriverHW::bGetDevSpecific()
/*++
Routine Description:
Gets the HW (!) Device Specific info
Arguments:
N/A
Return Value:
True or False (in this example).
--*/
{
return m_bDevSpecific;
} // bGetDevSpecific
//=============================================================================
void
CBaseAudioDriverHW::bSetDevSpecific
(
_In_ BOOL bDevSpecific
)
/*++
Routine Description:
Sets the HW (!) Device Specific info
Arguments:
fDevSpecific - true or false for this example.
Return Value:
void
--*/
{
m_bDevSpecific = bDevSpecific;
} // bSetDevSpecific
//=============================================================================
INT
CBaseAudioDriverHW::iGetDevSpecific()
/*++
Routine Description:
Gets the HW (!) Device Specific info
Arguments:
N/A
Return Value:
int (in this example).
--*/
{
return m_iDevSpecific;
} // iGetDevSpecific
//=============================================================================
void
CBaseAudioDriverHW::iSetDevSpecific
(
_In_ INT iDevSpecific
)
/*++
Routine Description:
Sets the HW (!) Device Specific info
Arguments:
fDevSpecific - true or false for this example.
Return Value:
void
--*/
{
m_iDevSpecific = iDevSpecific;
} // iSetDevSpecific
//=============================================================================
UINT
CBaseAudioDriverHW::uiGetDevSpecific()
/*++
Routine Description:
Gets the HW (!) Device Specific info
Arguments:
N/A
Return Value:
UINT (in this example).
--*/
{
return m_uiDevSpecific;
} // uiGetDevSpecific
//=============================================================================
void
CBaseAudioDriverHW::uiSetDevSpecific
(
_In_ UINT uiDevSpecific
)
/*++
Routine Description:
Sets the HW (!) Device Specific info
Arguments:
uiDevSpecific - int for this example.
Return Value:
void
--*/
{
m_uiDevSpecific = uiDevSpecific;
} // uiSetDevSpecific
//=============================================================================
BOOL
CBaseAudioDriverHW::GetMixerMute
(
_In_ ULONG ulNode,
_In_ ULONG ulChannel
)
/*++
Routine Description:
Gets the HW (!) mute levels for Base Audio Driver
Arguments:
ulNode - topology node id
ulChannel - which channel are we reading?
Return Value:
mute setting
--*/
{
UNREFERENCED_PARAMETER(ulChannel);
if (ulNode < MAX_TOPOLOGY_NODES)
{
return m_MuteControls[ulNode];
}
return 0;
} // GetMixerMute
//=============================================================================
ULONG
CBaseAudioDriverHW::GetMixerMux()
/*++
Routine Description:
Return the current mux selection
Arguments:
Return Value:
ULONG
--*/
{
return m_ulMux;
} // GetMixerMux
//=============================================================================
LONG
CBaseAudioDriverHW::GetMixerVolume
(
_In_ ULONG ulNode,
_In_ ULONG ulChannel
)
/*++
Routine Description:
Gets the HW (!) volume for Base Audio Driver.
Arguments:
ulNode - topology node id
ulChannel - which channel are we reading?
Return Value:
LONG - volume level
--*/
{
UNREFERENCED_PARAMETER(ulChannel);
if (ulNode < MAX_TOPOLOGY_NODES)
{
return m_VolumeControls[ulNode];
}
return 0;
} // GetMixerVolume
//=============================================================================
LONG
CBaseAudioDriverHW::GetMixerPeakMeter
(
_In_ ULONG ulNode,
_In_ ULONG ulChannel
)
/*++
Routine Description:
Gets the HW (!) peak meter for Base Audio Driver.
Arguments:
ulNode - topology node id
ulChannel - which channel are we reading?
Return Value:
LONG - sample peak meter level
--*/
{
UNREFERENCED_PARAMETER(ulChannel);
if (ulNode < MAX_TOPOLOGY_NODES)
{
return m_PeakMeterControls[ulNode];
}
return 0;
} // GetMixerVolume
//=============================================================================
#pragma code_seg("PAGE")
void
CBaseAudioDriverHW::MixerReset()
/*++
Routine Description:
Resets the mixer registers.
Arguments:
Return Value:
void
--*/
{
PAGED_CODE();
RtlFillMemory(m_VolumeControls, sizeof(LONG) * MAX_TOPOLOGY_NODES, 0xFF);
// Endpoints are not muted by default.
RtlZeroMemory(m_MuteControls, sizeof(BOOL) * MAX_TOPOLOGY_NODES);
for (ULONG i=0; i<MAX_TOPOLOGY_NODES; ++i)
{
m_PeakMeterControls[i] = PEAKMETER_SIGNED_MAXIMUM/2;
}
// BUGBUG change this depending on the topology
m_ulMux = 2;
} // MixerReset
#pragma code_seg()
//=============================================================================
void
CBaseAudioDriverHW::SetMixerMute
(
_In_ ULONG ulNode,
_In_ ULONG ulChannel,
_In_ BOOL fMute
)
/*++
Routine Description:
Sets the HW (!) mute levels for Base Audio Driver
Arguments:
ulNode - topology node id
ulChannel - which channel are we setting?
fMute - mute flag
Return Value:
void
--*/
{
UNREFERENCED_PARAMETER(ulChannel);
if (ulNode < MAX_TOPOLOGY_NODES)
{
m_MuteControls[ulNode] = fMute;
}
} // SetMixerMute
//=============================================================================
void
CBaseAudioDriverHW::SetMixerMux
(
_In_ ULONG ulNode
)
/*++
Routine Description:
Sets the HW (!) mux selection
Arguments:
ulNode - topology node id
Return Value:
void
--*/
{
m_ulMux = ulNode;
} // SetMixMux
//=============================================================================
void
CBaseAudioDriverHW::SetMixerVolume
(
_In_ ULONG ulNode,
_In_ ULONG ulChannel,
_In_ LONG lVolume
)
/*++
Routine Description:
Sets the HW (!) volume for Base Audio Driver.
Arguments:
ulNode - topology node id
ulChannel - which channel are we setting?
lVolume - volume level
Return Value:
void
--*/
{
UNREFERENCED_PARAMETER(ulChannel);
if (ulNode < MAX_TOPOLOGY_NODES)
{
m_VolumeControls[ulNode] = lVolume;
}
} // SetMixerVolume
| 16.483221 | 79 | 0.522394 | nicsor |
4b1c9e8900f34880e00164082839b01c82eeb2ba | 1,713 | cpp | C++ | Code/Projects/Eldritch/src/eldritchmusic.cpp | Johnicholas/EldritchCopy | 96b49cee8b5d4f0a72784ff19bdbec6ee0c96a30 | [
"Zlib"
] | 1 | 2016-07-26T13:19:27.000Z | 2016-07-26T13:19:27.000Z | Code/Projects/Eldritch/src/eldritchmusic.cpp | Johnicholas/EldritchCopy | 96b49cee8b5d4f0a72784ff19bdbec6ee0c96a30 | [
"Zlib"
] | null | null | null | Code/Projects/Eldritch/src/eldritchmusic.cpp | Johnicholas/EldritchCopy | 96b49cee8b5d4f0a72784ff19bdbec6ee0c96a30 | [
"Zlib"
] | null | null | null | #include "core.h"
#include "eldritchmusic.h"
#include "isoundinstance.h"
#include "eldritchframework.h"
EldritchMusic::EldritchMusic()
: m_MusicInstance( NULL )
{
IAudioSystem* const pAudioSystem = EldritchFramework::GetInstance()->GetAudioSystem();
ASSERT( pAudioSystem );
SInstanceDeleteCallback Callback;
Callback.m_Callback = InstanceDeleteCallback;
Callback.m_Void = this;
pAudioSystem->RegisterInstanceDeleteCallback( Callback );
}
EldritchMusic::~EldritchMusic()
{
IAudioSystem* const pAudioSystem = EldritchFramework::GetInstance()->GetAudioSystem();
ASSERT( pAudioSystem );
if( m_MusicInstance )
{
pAudioSystem->RemoveSoundInstance( m_MusicInstance );
}
SInstanceDeleteCallback Callback;
Callback.m_Callback = InstanceDeleteCallback;
Callback.m_Void = this;
pAudioSystem->UnregisterInstanceDeleteCallback( Callback );
}
void EldritchMusic::PlayMusic( const SimpleString& MusicSoundDef )
{
StopMusic();
if( MusicSoundDef == "" )
{
return;
}
IAudioSystem* const pAudioSystem = EldritchFramework::GetInstance()->GetAudioSystem();
ASSERT( pAudioSystem );
m_MusicInstance = pAudioSystem->CreateSoundInstance( MusicSoundDef );
ASSERT( m_MusicInstance );
m_MusicInstance->Tick();
m_MusicInstance->Play();
}
void EldritchMusic::StopMusic()
{
if( m_MusicInstance )
{
m_MusicInstance->Stop();
}
}
/*static*/ void EldritchMusic::InstanceDeleteCallback( void* pVoid, ISoundInstance* pInstance )
{
EldritchMusic* pMusic = static_cast<EldritchMusic*>( pVoid );
ASSERT( pMusic );
pMusic->OnInstanceDeleted( pInstance );
}
void EldritchMusic::OnInstanceDeleted( ISoundInstance* const pInstance )
{
if( pInstance == m_MusicInstance )
{
m_MusicInstance = NULL;
}
} | 22.84 | 95 | 0.760654 | Johnicholas |
4b1e6f87843e4d6379384adb28c73d3cfb7889bb | 49,718 | cc | C++ | src/client/linux/minidump_writer/minidump_writer.cc | zzilla/gbreakpad | 02fd5a078bda4eb2fd7ee881c8d301bea2bf87fe | [
"BSD-3-Clause"
] | 19 | 2018-06-25T09:35:22.000Z | 2021-12-04T19:09:52.000Z | src/client/linux/minidump_writer/minidump_writer.cc | zzilla/gbreakpad | 02fd5a078bda4eb2fd7ee881c8d301bea2bf87fe | [
"BSD-3-Clause"
] | 2 | 2020-09-22T20:42:16.000Z | 2020-11-11T04:08:57.000Z | src/client/linux/minidump_writer/minidump_writer.cc | zzilla/gbreakpad | 02fd5a078bda4eb2fd7ee881c8d301bea2bf87fe | [
"BSD-3-Clause"
] | 11 | 2020-07-04T03:03:18.000Z | 2022-03-17T10:19:19.000Z | // Copyright (c) 2010, Google Inc.
// 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 Google Inc. 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.
// This code writes out minidump files:
// http://msdn.microsoft.com/en-us/library/ms680378(VS.85,loband).aspx
//
// Minidumps are a Microsoft format which Breakpad uses for recording crash
// dumps. This code has to run in a compromised environment (the address space
// may have received SIGSEGV), thus the following rules apply:
// * You may not enter the dynamic linker. This means that we cannot call
// any symbols in a shared library (inc libc). Because of this we replace
// libc functions in linux_libc_support.h.
// * You may not call syscalls via the libc wrappers. This rule is a subset
// of the first rule but it bears repeating. We have direct wrappers
// around the system calls in linux_syscall_support.h.
// * You may not malloc. There's an alternative allocator in memory.h and
// a canonical instance in the LinuxDumper object. We use the placement
// new form to allocate objects and we don't delete them.
#include "client/linux/handler/minidump_descriptor.h"
#include "client/linux/minidump_writer/minidump_writer.h"
#include "client/minidump_file_writer-inl.h"
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <link.h>
#include <stdio.h>
#if defined(__ANDROID__)
#include <sys/system_properties.h>
#endif
#include <sys/types.h>
#include <sys/ucontext.h>
#include <sys/user.h>
#include <sys/utsname.h>
#include <time.h>
#include <unistd.h>
#include <algorithm>
#include "client/linux/dump_writer_common/thread_info.h"
#include "client/linux/dump_writer_common/ucontext_reader.h"
#include "client/linux/handler/exception_handler.h"
#include "client/linux/minidump_writer/cpu_set.h"
#include "client/linux/minidump_writer/line_reader.h"
#include "client/linux/minidump_writer/linux_dumper.h"
#include "client/linux/minidump_writer/linux_ptrace_dumper.h"
#include "client/linux/minidump_writer/proc_cpuinfo_reader.h"
#include "client/minidump_file_writer.h"
#include "common/linux/linux_libc_support.h"
#include "common/minidump_type_helper.h"
#include "google_breakpad/common/minidump_format.h"
#include "third_party/lss/linux_syscall_support.h"
namespace {
using google_breakpad::AppMemoryList;
using google_breakpad::ExceptionHandler;
using google_breakpad::CpuSet;
using google_breakpad::LineReader;
using google_breakpad::LinuxDumper;
using google_breakpad::LinuxPtraceDumper;
using google_breakpad::MDTypeHelper;
using google_breakpad::MappingEntry;
using google_breakpad::MappingInfo;
using google_breakpad::MappingList;
using google_breakpad::MinidumpFileWriter;
using google_breakpad::PageAllocator;
using google_breakpad::ProcCpuInfoReader;
using google_breakpad::RawContextCPU;
using google_breakpad::ThreadInfo;
using google_breakpad::TypedMDRVA;
using google_breakpad::UContextReader;
using google_breakpad::UntypedMDRVA;
using google_breakpad::wasteful_vector;
typedef MDTypeHelper<sizeof(void*)>::MDRawDebug MDRawDebug;
typedef MDTypeHelper<sizeof(void*)>::MDRawLinkMap MDRawLinkMap;
class MinidumpWriter {
public:
// The following kLimit* constants are for when minidump_size_limit_ is set
// and the minidump size might exceed it.
//
// Estimate for how big each thread's stack will be (in bytes).
static const unsigned kLimitAverageThreadStackLength = 8 * 1024;
// Number of threads whose stack size we don't want to limit. These base
// threads will simply be the first N threads returned by the dumper (although
// the crashing thread will never be limited). Threads beyond this count are
// the extra threads.
static const unsigned kLimitBaseThreadCount = 20;
// Maximum stack size to dump for any extra thread (in bytes).
static const unsigned kLimitMaxExtraThreadStackLen = 2 * 1024;
// Make sure this number of additional bytes can fit in the minidump
// (exclude the stack data).
static const unsigned kLimitMinidumpFudgeFactor = 64 * 1024;
MinidumpWriter(const char* minidump_path,
int minidump_fd,
const ExceptionHandler::CrashContext* context,
const MappingList& mappings,
const AppMemoryList& appmem,
LinuxDumper* dumper)
: fd_(minidump_fd),
path_(minidump_path),
ucontext_(context ? &context->context : NULL),
#if !defined(__ARM_EABI__) && !defined(__mips__)
float_state_(context ? &context->float_state : NULL),
#endif
dumper_(dumper),
minidump_size_limit_(-1),
memory_blocks_(dumper_->allocator()),
mapping_list_(mappings),
app_memory_list_(appmem) {
// Assert there should be either a valid fd or a valid path, not both.
assert(fd_ != -1 || minidump_path);
assert(fd_ == -1 || !minidump_path);
}
bool Init() {
if (!dumper_->Init())
return false;
if (fd_ != -1)
minidump_writer_.SetFile(fd_);
else if (!minidump_writer_.Open(path_))
return false;
return dumper_->ThreadsSuspend() && dumper_->LateInit();
}
~MinidumpWriter() {
// Don't close the file descriptor when it's been provided explicitly.
// Callers might still need to use it.
if (fd_ == -1)
minidump_writer_.Close();
dumper_->ThreadsResume();
}
bool Dump() {
// A minidump file contains a number of tagged streams. This is the number
// of stream which we write.
unsigned kNumWriters = 13;
TypedMDRVA<MDRawHeader> header(&minidump_writer_);
TypedMDRVA<MDRawDirectory> dir(&minidump_writer_);
if (!header.Allocate())
return false;
if (!dir.AllocateArray(kNumWriters))
return false;
my_memset(header.get(), 0, sizeof(MDRawHeader));
header.get()->signature = MD_HEADER_SIGNATURE;
header.get()->version = MD_HEADER_VERSION;
header.get()->time_date_stamp = time(NULL);
header.get()->stream_count = kNumWriters;
header.get()->stream_directory_rva = dir.position();
unsigned dir_index = 0;
MDRawDirectory dirent;
if (!WriteThreadListStream(&dirent))
return false;
dir.CopyIndex(dir_index++, &dirent);
if (!WriteMappings(&dirent))
return false;
dir.CopyIndex(dir_index++, &dirent);
if (!WriteAppMemory())
return false;
if (!WriteMemoryListStream(&dirent))
return false;
dir.CopyIndex(dir_index++, &dirent);
if (!WriteExceptionStream(&dirent))
return false;
dir.CopyIndex(dir_index++, &dirent);
if (!WriteSystemInfoStream(&dirent))
return false;
dir.CopyIndex(dir_index++, &dirent);
dirent.stream_type = MD_LINUX_CPU_INFO;
if (!WriteFile(&dirent.location, "/proc/cpuinfo"))
NullifyDirectoryEntry(&dirent);
dir.CopyIndex(dir_index++, &dirent);
dirent.stream_type = MD_LINUX_PROC_STATUS;
if (!WriteProcFile(&dirent.location, GetCrashThread(), "status"))
NullifyDirectoryEntry(&dirent);
dir.CopyIndex(dir_index++, &dirent);
dirent.stream_type = MD_LINUX_LSB_RELEASE;
if (!WriteFile(&dirent.location, "/etc/lsb-release"))
NullifyDirectoryEntry(&dirent);
dir.CopyIndex(dir_index++, &dirent);
dirent.stream_type = MD_LINUX_CMD_LINE;
if (!WriteProcFile(&dirent.location, GetCrashThread(), "cmdline"))
NullifyDirectoryEntry(&dirent);
dir.CopyIndex(dir_index++, &dirent);
dirent.stream_type = MD_LINUX_ENVIRON;
if (!WriteProcFile(&dirent.location, GetCrashThread(), "environ"))
NullifyDirectoryEntry(&dirent);
dir.CopyIndex(dir_index++, &dirent);
dirent.stream_type = MD_LINUX_AUXV;
if (!WriteProcFile(&dirent.location, GetCrashThread(), "auxv"))
NullifyDirectoryEntry(&dirent);
dir.CopyIndex(dir_index++, &dirent);
dirent.stream_type = MD_LINUX_MAPS;
if (!WriteProcFile(&dirent.location, GetCrashThread(), "maps"))
NullifyDirectoryEntry(&dirent);
dir.CopyIndex(dir_index++, &dirent);
dirent.stream_type = MD_LINUX_DSO_DEBUG;
if (!WriteDSODebugStream(&dirent))
NullifyDirectoryEntry(&dirent);
dir.CopyIndex(dir_index++, &dirent);
// If you add more directory entries, don't forget to update kNumWriters,
// above.
dumper_->ThreadsResume();
return true;
}
bool FillThreadStack(MDRawThread* thread, uintptr_t stack_pointer,
int max_stack_len, uint8_t** stack_copy) {
*stack_copy = NULL;
const void* stack;
size_t stack_len;
if (dumper_->GetStackInfo(&stack, &stack_len, stack_pointer)) {
UntypedMDRVA memory(&minidump_writer_);
if (max_stack_len >= 0 &&
stack_len > static_cast<unsigned int>(max_stack_len)) {
stack_len = max_stack_len;
}
if (!memory.Allocate(stack_len))
return false;
*stack_copy = reinterpret_cast<uint8_t*>(Alloc(stack_len));
dumper_->CopyFromProcess(*stack_copy, thread->thread_id, stack,
stack_len);
memory.Copy(*stack_copy, stack_len);
thread->stack.start_of_memory_range =
reinterpret_cast<uintptr_t>(stack);
thread->stack.memory = memory.location();
memory_blocks_.push_back(thread->stack);
} else {
thread->stack.start_of_memory_range = stack_pointer;
thread->stack.memory.data_size = 0;
thread->stack.memory.rva = minidump_writer_.position();
}
return true;
}
// Write information about the threads.
bool WriteThreadListStream(MDRawDirectory* dirent) {
const unsigned num_threads = dumper_->threads().size();
TypedMDRVA<uint32_t> list(&minidump_writer_);
if (!list.AllocateObjectAndArray(num_threads, sizeof(MDRawThread)))
return false;
dirent->stream_type = MD_THREAD_LIST_STREAM;
dirent->location = list.location();
*list.get() = num_threads;
// If there's a minidump size limit, check if it might be exceeded. Since
// most of the space is filled with stack data, just check against that.
// If this expects to exceed the limit, set extra_thread_stack_len such
// that any thread beyond the first kLimitBaseThreadCount threads will
// have only kLimitMaxExtraThreadStackLen bytes dumped.
int extra_thread_stack_len = -1; // default to no maximum
if (minidump_size_limit_ >= 0) {
const unsigned estimated_total_stack_size = num_threads *
kLimitAverageThreadStackLength;
const off_t estimated_minidump_size = minidump_writer_.position() +
estimated_total_stack_size + kLimitMinidumpFudgeFactor;
if (estimated_minidump_size > minidump_size_limit_)
extra_thread_stack_len = kLimitMaxExtraThreadStackLen;
}
for (unsigned i = 0; i < num_threads; ++i) {
MDRawThread thread;
my_memset(&thread, 0, sizeof(thread));
thread.thread_id = dumper_->threads()[i];
// We have a different source of information for the crashing thread. If
// we used the actual state of the thread we would find it running in the
// signal handler with the alternative stack, which would be deeply
// unhelpful.
if (static_cast<pid_t>(thread.thread_id) == GetCrashThread() &&
ucontext_ &&
!dumper_->IsPostMortem()) {
uint8_t* stack_copy;
const uintptr_t stack_ptr = UContextReader::GetStackPointer(ucontext_);
if (!FillThreadStack(&thread, stack_ptr, -1, &stack_copy))
return false;
// Copy 256 bytes around crashing instruction pointer to minidump.
const size_t kIPMemorySize = 256;
uint64_t ip = UContextReader::GetInstructionPointer(ucontext_);
// Bound it to the upper and lower bounds of the memory map
// it's contained within. If it's not in mapped memory,
// don't bother trying to write it.
bool ip_is_mapped = false;
MDMemoryDescriptor ip_memory_d;
for (unsigned j = 0; j < dumper_->mappings().size(); ++j) {
const MappingInfo& mapping = *dumper_->mappings()[j];
if (ip >= mapping.start_addr &&
ip < mapping.start_addr + mapping.size) {
ip_is_mapped = true;
// Try to get 128 bytes before and after the IP, but
// settle for whatever's available.
ip_memory_d.start_of_memory_range =
std::max(mapping.start_addr,
uintptr_t(ip - (kIPMemorySize / 2)));
uintptr_t end_of_range =
std::min(uintptr_t(ip + (kIPMemorySize / 2)),
uintptr_t(mapping.start_addr + mapping.size));
ip_memory_d.memory.data_size =
end_of_range - ip_memory_d.start_of_memory_range;
break;
}
}
if (ip_is_mapped) {
UntypedMDRVA ip_memory(&minidump_writer_);
if (!ip_memory.Allocate(ip_memory_d.memory.data_size))
return false;
uint8_t* memory_copy =
reinterpret_cast<uint8_t*>(Alloc(ip_memory_d.memory.data_size));
dumper_->CopyFromProcess(
memory_copy,
thread.thread_id,
reinterpret_cast<void*>(ip_memory_d.start_of_memory_range),
ip_memory_d.memory.data_size);
ip_memory.Copy(memory_copy, ip_memory_d.memory.data_size);
ip_memory_d.memory = ip_memory.location();
memory_blocks_.push_back(ip_memory_d);
}
TypedMDRVA<RawContextCPU> cpu(&minidump_writer_);
if (!cpu.Allocate())
return false;
my_memset(cpu.get(), 0, sizeof(RawContextCPU));
#if !defined(__ARM_EABI__) && !defined(__mips__)
UContextReader::FillCPUContext(cpu.get(), ucontext_, float_state_);
#else
UContextReader::FillCPUContext(cpu.get(), ucontext_);
#endif
thread.thread_context = cpu.location();
crashing_thread_context_ = cpu.location();
} else {
ThreadInfo info;
if (!dumper_->GetThreadInfoByIndex(i, &info))
return false;
uint8_t* stack_copy;
int max_stack_len = -1; // default to no maximum for this thread
if (minidump_size_limit_ >= 0 && i >= kLimitBaseThreadCount)
max_stack_len = extra_thread_stack_len;
if (!FillThreadStack(&thread, info.stack_pointer, max_stack_len,
&stack_copy))
return false;
TypedMDRVA<RawContextCPU> cpu(&minidump_writer_);
if (!cpu.Allocate())
return false;
my_memset(cpu.get(), 0, sizeof(RawContextCPU));
info.FillCPUContext(cpu.get());
thread.thread_context = cpu.location();
if (dumper_->threads()[i] == GetCrashThread()) {
crashing_thread_context_ = cpu.location();
if (!dumper_->IsPostMortem()) {
// This is the crashing thread of a live process, but
// no context was provided, so set the crash address
// while the instruction pointer is already here.
dumper_->set_crash_address(info.GetInstructionPointer());
}
}
}
list.CopyIndexAfterObject(i, &thread, sizeof(thread));
}
return true;
}
// Write application-provided memory regions.
bool WriteAppMemory() {
for (AppMemoryList::const_iterator iter = app_memory_list_.begin();
iter != app_memory_list_.end();
++iter) {
uint8_t* data_copy =
reinterpret_cast<uint8_t*>(dumper_->allocator()->Alloc(iter->length));
dumper_->CopyFromProcess(data_copy, GetCrashThread(), iter->ptr,
iter->length);
UntypedMDRVA memory(&minidump_writer_);
if (!memory.Allocate(iter->length)) {
return false;
}
memory.Copy(data_copy, iter->length);
MDMemoryDescriptor desc;
desc.start_of_memory_range = reinterpret_cast<uintptr_t>(iter->ptr);
desc.memory = memory.location();
memory_blocks_.push_back(desc);
}
return true;
}
static bool ShouldIncludeMapping(const MappingInfo& mapping) {
if (mapping.name[0] == 0 || // only want modules with filenames.
// Only want to include one mapping per shared lib.
// Avoid filtering executable mappings.
(mapping.offset != 0 && !mapping.exec) ||
mapping.size < 4096) { // too small to get a signature for.
return false;
}
return true;
}
// If there is caller-provided information about this mapping
// in the mapping_list_ list, return true. Otherwise, return false.
bool HaveMappingInfo(const MappingInfo& mapping) {
for (MappingList::const_iterator iter = mapping_list_.begin();
iter != mapping_list_.end();
++iter) {
// Ignore any mappings that are wholly contained within
// mappings in the mapping_info_ list.
if (mapping.start_addr >= iter->first.start_addr &&
(mapping.start_addr + mapping.size) <=
(iter->first.start_addr + iter->first.size)) {
return true;
}
}
return false;
}
// Write information about the mappings in effect. Because we are using the
// minidump format, the information about the mappings is pretty limited.
// Because of this, we also include the full, unparsed, /proc/$x/maps file in
// another stream in the file.
bool WriteMappings(MDRawDirectory* dirent) {
const unsigned num_mappings = dumper_->mappings().size();
unsigned num_output_mappings = mapping_list_.size();
for (unsigned i = 0; i < dumper_->mappings().size(); ++i) {
const MappingInfo& mapping = *dumper_->mappings()[i];
if (ShouldIncludeMapping(mapping) && !HaveMappingInfo(mapping))
num_output_mappings++;
}
TypedMDRVA<uint32_t> list(&minidump_writer_);
if (num_output_mappings) {
if (!list.AllocateObjectAndArray(num_output_mappings, MD_MODULE_SIZE))
return false;
} else {
// Still create the module list stream, although it will have zero
// modules.
if (!list.Allocate())
return false;
}
dirent->stream_type = MD_MODULE_LIST_STREAM;
dirent->location = list.location();
*list.get() = num_output_mappings;
// First write all the mappings from the dumper
unsigned int j = 0;
for (unsigned i = 0; i < num_mappings; ++i) {
const MappingInfo& mapping = *dumper_->mappings()[i];
if (!ShouldIncludeMapping(mapping) || HaveMappingInfo(mapping))
continue;
MDRawModule mod;
if (!FillRawModule(mapping, true, i, mod, NULL))
return false;
list.CopyIndexAfterObject(j++, &mod, MD_MODULE_SIZE);
}
// Next write all the mappings provided by the caller
for (MappingList::const_iterator iter = mapping_list_.begin();
iter != mapping_list_.end();
++iter) {
MDRawModule mod;
if (!FillRawModule(iter->first, false, 0, mod, iter->second))
return false;
list.CopyIndexAfterObject(j++, &mod, MD_MODULE_SIZE);
}
return true;
}
// Fill the MDRawModule |mod| with information about the provided
// |mapping|. If |identifier| is non-NULL, use it instead of calculating
// a file ID from the mapping.
bool FillRawModule(const MappingInfo& mapping,
bool member,
unsigned int mapping_id,
MDRawModule& mod,
const uint8_t* identifier) {
my_memset(&mod, 0, MD_MODULE_SIZE);
mod.base_of_image = mapping.start_addr;
mod.size_of_image = mapping.size;
uint8_t cv_buf[MDCVInfoPDB70_minsize + NAME_MAX];
uint8_t* cv_ptr = cv_buf;
const uint32_t cv_signature = MD_CVINFOPDB70_SIGNATURE;
my_memcpy(cv_ptr, &cv_signature, sizeof(cv_signature));
cv_ptr += sizeof(cv_signature);
uint8_t* signature = cv_ptr;
cv_ptr += sizeof(MDGUID);
if (identifier) {
// GUID was provided by caller.
my_memcpy(signature, identifier, sizeof(MDGUID));
} else {
// Note: ElfFileIdentifierForMapping() can manipulate the |mapping.name|.
dumper_->ElfFileIdentifierForMapping(mapping, member,
mapping_id, signature);
}
my_memset(cv_ptr, 0, sizeof(uint32_t)); // Set age to 0 on Linux.
cv_ptr += sizeof(uint32_t);
char file_name[NAME_MAX];
char file_path[NAME_MAX];
LinuxDumper::GetMappingEffectiveNameAndPath(
mapping, file_path, sizeof(file_path), file_name, sizeof(file_name));
const size_t file_name_len = my_strlen(file_name);
UntypedMDRVA cv(&minidump_writer_);
if (!cv.Allocate(MDCVInfoPDB70_minsize + file_name_len + 1))
return false;
// Write pdb_file_name
my_memcpy(cv_ptr, file_name, file_name_len + 1);
cv.Copy(cv_buf, MDCVInfoPDB70_minsize + file_name_len + 1);
mod.cv_record = cv.location();
MDLocationDescriptor ld;
if (!minidump_writer_.WriteString(file_path, my_strlen(file_path), &ld))
return false;
mod.module_name_rva = ld.rva;
return true;
}
bool WriteMemoryListStream(MDRawDirectory* dirent) {
TypedMDRVA<uint32_t> list(&minidump_writer_);
if (memory_blocks_.size()) {
if (!list.AllocateObjectAndArray(memory_blocks_.size(),
sizeof(MDMemoryDescriptor)))
return false;
} else {
// Still create the memory list stream, although it will have zero
// memory blocks.
if (!list.Allocate())
return false;
}
dirent->stream_type = MD_MEMORY_LIST_STREAM;
dirent->location = list.location();
*list.get() = memory_blocks_.size();
for (size_t i = 0; i < memory_blocks_.size(); ++i) {
list.CopyIndexAfterObject(i, &memory_blocks_[i],
sizeof(MDMemoryDescriptor));
}
return true;
}
bool WriteExceptionStream(MDRawDirectory* dirent) {
TypedMDRVA<MDRawExceptionStream> exc(&minidump_writer_);
if (!exc.Allocate())
return false;
my_memset(exc.get(), 0, sizeof(MDRawExceptionStream));
dirent->stream_type = MD_EXCEPTION_STREAM;
dirent->location = exc.location();
exc.get()->thread_id = GetCrashThread();
exc.get()->exception_record.exception_code = dumper_->crash_signal();
exc.get()->exception_record.exception_address = dumper_->crash_address();
exc.get()->thread_context = crashing_thread_context_;
return true;
}
bool WriteSystemInfoStream(MDRawDirectory* dirent) {
TypedMDRVA<MDRawSystemInfo> si(&minidump_writer_);
if (!si.Allocate())
return false;
my_memset(si.get(), 0, sizeof(MDRawSystemInfo));
dirent->stream_type = MD_SYSTEM_INFO_STREAM;
dirent->location = si.location();
WriteCPUInformation(si.get());
WriteOSInformation(si.get());
return true;
}
bool WriteDSODebugStream(MDRawDirectory* dirent) {
ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr) *>(dumper_->auxv()[AT_PHDR]);
char* base;
int phnum = dumper_->auxv()[AT_PHNUM];
if (!phnum || !phdr)
return false;
// Assume the program base is at the beginning of the same page as the PHDR
base = reinterpret_cast<char *>(reinterpret_cast<uintptr_t>(phdr) & ~0xfff);
// Search for the program PT_DYNAMIC segment
ElfW(Addr) dyn_addr = 0;
for (; phnum >= 0; phnum--, phdr++) {
ElfW(Phdr) ph;
if (!dumper_->CopyFromProcess(&ph, GetCrashThread(), phdr, sizeof(ph)))
return false;
// Adjust base address with the virtual address of the PT_LOAD segment
// corresponding to offset 0
if (ph.p_type == PT_LOAD && ph.p_offset == 0) {
base -= ph.p_vaddr;
}
if (ph.p_type == PT_DYNAMIC) {
dyn_addr = ph.p_vaddr;
}
}
if (!dyn_addr)
return false;
ElfW(Dyn) *dynamic = reinterpret_cast<ElfW(Dyn) *>(dyn_addr + base);
// The dynamic linker makes information available that helps gdb find all
// DSOs loaded into the program. If this information is indeed available,
// dump it to a MD_LINUX_DSO_DEBUG stream.
struct r_debug* r_debug = NULL;
uint32_t dynamic_length = 0;
for (int i = 0; ; ++i) {
ElfW(Dyn) dyn;
dynamic_length += sizeof(dyn);
if (!dumper_->CopyFromProcess(&dyn, GetCrashThread(), dynamic + i,
sizeof(dyn))) {
return false;
}
#ifdef __mips__
if (dyn.d_tag == DT_MIPS_RLD_MAP) {
r_debug = reinterpret_cast<struct r_debug*>(dyn.d_un.d_ptr);
continue;
}
#else
if (dyn.d_tag == DT_DEBUG) {
r_debug = reinterpret_cast<struct r_debug*>(dyn.d_un.d_ptr);
continue;
}
#endif
else if (dyn.d_tag == DT_NULL) {
break;
}
}
// The "r_map" field of that r_debug struct contains a linked list of all
// loaded DSOs.
// Our list of DSOs potentially is different from the ones in the crashing
// process. So, we have to be careful to never dereference pointers
// directly. Instead, we use CopyFromProcess() everywhere.
// See <link.h> for a more detailed discussion of the how the dynamic
// loader communicates with debuggers.
// Count the number of loaded DSOs
int dso_count = 0;
struct r_debug debug_entry;
if (!dumper_->CopyFromProcess(&debug_entry, GetCrashThread(), r_debug,
sizeof(debug_entry))) {
return false;
}
for (struct link_map* ptr = debug_entry.r_map; ptr; ) {
struct link_map map;
if (!dumper_->CopyFromProcess(&map, GetCrashThread(), ptr, sizeof(map)))
return false;
ptr = map.l_next;
dso_count++;
}
MDRVA linkmap_rva = minidump_writer_.kInvalidMDRVA;
if (dso_count > 0) {
// If we have at least one DSO, create an array of MDRawLinkMap
// entries in the minidump file.
TypedMDRVA<MDRawLinkMap> linkmap(&minidump_writer_);
if (!linkmap.AllocateArray(dso_count))
return false;
linkmap_rva = linkmap.location().rva;
int idx = 0;
// Iterate over DSOs and write their information to mini dump
for (struct link_map* ptr = debug_entry.r_map; ptr; ) {
struct link_map map;
if (!dumper_->CopyFromProcess(&map, GetCrashThread(), ptr, sizeof(map)))
return false;
ptr = map.l_next;
char filename[257] = { 0 };
if (map.l_name) {
dumper_->CopyFromProcess(filename, GetCrashThread(), map.l_name,
sizeof(filename) - 1);
}
MDLocationDescriptor location;
if (!minidump_writer_.WriteString(filename, 0, &location))
return false;
MDRawLinkMap entry;
entry.name = location.rva;
entry.addr = map.l_addr;
entry.ld = reinterpret_cast<uintptr_t>(map.l_ld);
linkmap.CopyIndex(idx++, &entry);
}
}
// Write MD_LINUX_DSO_DEBUG record
TypedMDRVA<MDRawDebug> debug(&minidump_writer_);
if (!debug.AllocateObjectAndArray(1, dynamic_length))
return false;
my_memset(debug.get(), 0, sizeof(MDRawDebug));
dirent->stream_type = MD_LINUX_DSO_DEBUG;
dirent->location = debug.location();
debug.get()->version = debug_entry.r_version;
debug.get()->map = linkmap_rva;
debug.get()->dso_count = dso_count;
debug.get()->brk = debug_entry.r_brk;
debug.get()->ldbase = debug_entry.r_ldbase;
debug.get()->dynamic = reinterpret_cast<uintptr_t>(dynamic);
wasteful_vector<char> dso_debug_data(dumper_->allocator(), dynamic_length);
// The passed-in size to the constructor (above) is only a hint.
// Must call .resize() to do actual initialization of the elements.
dso_debug_data.resize(dynamic_length);
dumper_->CopyFromProcess(&dso_debug_data[0], GetCrashThread(), dynamic,
dynamic_length);
debug.CopyIndexAfterObject(0, &dso_debug_data[0], dynamic_length);
return true;
}
void set_minidump_size_limit(off_t limit) { minidump_size_limit_ = limit; }
private:
void* Alloc(unsigned bytes) {
return dumper_->allocator()->Alloc(bytes);
}
pid_t GetCrashThread() const {
return dumper_->crash_thread();
}
void NullifyDirectoryEntry(MDRawDirectory* dirent) {
dirent->stream_type = 0;
dirent->location.data_size = 0;
dirent->location.rva = 0;
}
#if defined(__i386__) || defined(__x86_64__) || defined(__mips__)
bool WriteCPUInformation(MDRawSystemInfo* sys_info) {
char vendor_id[sizeof(sys_info->cpu.x86_cpu_info.vendor_id) + 1] = {0};
static const char vendor_id_name[] = "vendor_id";
struct CpuInfoEntry {
const char* info_name;
int value;
bool found;
} cpu_info_table[] = {
{ "processor", -1, false },
#if defined(__i386__) || defined(__x86_64__)
{ "model", 0, false },
{ "stepping", 0, false },
{ "cpu family", 0, false },
#endif
};
// processor_architecture should always be set, do this first
sys_info->processor_architecture =
#if defined(__mips__)
MD_CPU_ARCHITECTURE_MIPS;
#elif defined(__i386__)
MD_CPU_ARCHITECTURE_X86;
#else
MD_CPU_ARCHITECTURE_AMD64;
#endif
const int fd = sys_open("/proc/cpuinfo", O_RDONLY, 0);
if (fd < 0)
return false;
{
PageAllocator allocator;
ProcCpuInfoReader* const reader = new(allocator) ProcCpuInfoReader(fd);
const char* field;
while (reader->GetNextField(&field)) {
for (size_t i = 0;
i < sizeof(cpu_info_table) / sizeof(cpu_info_table[0]);
i++) {
CpuInfoEntry* entry = &cpu_info_table[i];
if (i > 0 && entry->found) {
// except for the 'processor' field, ignore repeated values.
continue;
}
if (!my_strcmp(field, entry->info_name)) {
size_t value_len;
const char* value = reader->GetValueAndLen(&value_len);
if (value_len == 0)
continue;
uintptr_t val;
if (my_read_decimal_ptr(&val, value) == value)
continue;
entry->value = static_cast<int>(val);
entry->found = true;
}
}
// special case for vendor_id
if (!my_strcmp(field, vendor_id_name)) {
size_t value_len;
const char* value = reader->GetValueAndLen(&value_len);
if (value_len > 0)
my_strlcpy(vendor_id, value, sizeof(vendor_id));
}
}
sys_close(fd);
}
// make sure we got everything we wanted
for (size_t i = 0;
i < sizeof(cpu_info_table) / sizeof(cpu_info_table[0]);
i++) {
if (!cpu_info_table[i].found) {
return false;
}
}
// cpu_info_table[0] holds the last cpu id listed in /proc/cpuinfo,
// assuming this is the highest id, change it to the number of CPUs
// by adding one.
cpu_info_table[0].value++;
sys_info->number_of_processors = cpu_info_table[0].value;
#if defined(__i386__) || defined(__x86_64__)
sys_info->processor_level = cpu_info_table[3].value;
sys_info->processor_revision = cpu_info_table[1].value << 8 |
cpu_info_table[2].value;
#endif
if (vendor_id[0] != '\0') {
my_memcpy(sys_info->cpu.x86_cpu_info.vendor_id, vendor_id,
sizeof(sys_info->cpu.x86_cpu_info.vendor_id));
}
return true;
}
#elif defined(__arm__) || defined(__aarch64__)
bool WriteCPUInformation(MDRawSystemInfo* sys_info) {
// The CPUID value is broken up in several entries in /proc/cpuinfo.
// This table is used to rebuild it from the entries.
const struct CpuIdEntry {
const char* field;
char format;
char bit_lshift;
char bit_length;
} cpu_id_entries[] = {
{ "CPU implementer", 'x', 24, 8 },
{ "CPU variant", 'x', 20, 4 },
{ "CPU part", 'x', 4, 12 },
{ "CPU revision", 'd', 0, 4 },
};
// The ELF hwcaps are listed in the "Features" entry as textual tags.
// This table is used to rebuild them.
const struct CpuFeaturesEntry {
const char* tag;
uint32_t hwcaps;
} cpu_features_entries[] = {
#if defined(__arm__)
{ "swp", MD_CPU_ARM_ELF_HWCAP_SWP },
{ "half", MD_CPU_ARM_ELF_HWCAP_HALF },
{ "thumb", MD_CPU_ARM_ELF_HWCAP_THUMB },
{ "26bit", MD_CPU_ARM_ELF_HWCAP_26BIT },
{ "fastmult", MD_CPU_ARM_ELF_HWCAP_FAST_MULT },
{ "fpa", MD_CPU_ARM_ELF_HWCAP_FPA },
{ "vfp", MD_CPU_ARM_ELF_HWCAP_VFP },
{ "edsp", MD_CPU_ARM_ELF_HWCAP_EDSP },
{ "java", MD_CPU_ARM_ELF_HWCAP_JAVA },
{ "iwmmxt", MD_CPU_ARM_ELF_HWCAP_IWMMXT },
{ "crunch", MD_CPU_ARM_ELF_HWCAP_CRUNCH },
{ "thumbee", MD_CPU_ARM_ELF_HWCAP_THUMBEE },
{ "neon", MD_CPU_ARM_ELF_HWCAP_NEON },
{ "vfpv3", MD_CPU_ARM_ELF_HWCAP_VFPv3 },
{ "vfpv3d16", MD_CPU_ARM_ELF_HWCAP_VFPv3D16 },
{ "tls", MD_CPU_ARM_ELF_HWCAP_TLS },
{ "vfpv4", MD_CPU_ARM_ELF_HWCAP_VFPv4 },
{ "idiva", MD_CPU_ARM_ELF_HWCAP_IDIVA },
{ "idivt", MD_CPU_ARM_ELF_HWCAP_IDIVT },
{ "idiv", MD_CPU_ARM_ELF_HWCAP_IDIVA | MD_CPU_ARM_ELF_HWCAP_IDIVT },
#elif defined(__aarch64__)
// No hwcaps on aarch64.
#endif
};
// processor_architecture should always be set, do this first
sys_info->processor_architecture =
#if defined(__aarch64__)
MD_CPU_ARCHITECTURE_ARM64;
#else
MD_CPU_ARCHITECTURE_ARM;
#endif
// /proc/cpuinfo is not readable under various sandboxed environments
// (e.g. Android services with the android:isolatedProcess attribute)
// prepare for this by setting default values now, which will be
// returned when this happens.
//
// Note: Bogus values are used to distinguish between failures (to
// read /sys and /proc files) and really badly configured kernels.
sys_info->number_of_processors = 0;
sys_info->processor_level = 1U; // There is no ARMv1
sys_info->processor_revision = 42;
sys_info->cpu.arm_cpu_info.cpuid = 0;
sys_info->cpu.arm_cpu_info.elf_hwcaps = 0;
// Counting the number of CPUs involves parsing two sysfs files,
// because the content of /proc/cpuinfo will only mirror the number
// of 'online' cores, and thus will vary with time.
// See http://www.kernel.org/doc/Documentation/cputopology.txt
{
CpuSet cpus_present;
CpuSet cpus_possible;
int fd = sys_open("/sys/devices/system/cpu/present", O_RDONLY, 0);
if (fd >= 0) {
cpus_present.ParseSysFile(fd);
sys_close(fd);
fd = sys_open("/sys/devices/system/cpu/possible", O_RDONLY, 0);
if (fd >= 0) {
cpus_possible.ParseSysFile(fd);
sys_close(fd);
cpus_present.IntersectWith(cpus_possible);
int cpu_count = cpus_present.GetCount();
if (cpu_count > 255)
cpu_count = 255;
sys_info->number_of_processors = static_cast<uint8_t>(cpu_count);
}
}
}
// Parse /proc/cpuinfo to reconstruct the CPUID value, as well
// as the ELF hwcaps field. For the latter, it would be easier to
// read /proc/self/auxv but unfortunately, this file is not always
// readable from regular Android applications on later versions
// (>= 4.1) of the Android platform.
const int fd = sys_open("/proc/cpuinfo", O_RDONLY, 0);
if (fd < 0) {
// Do not return false here to allow the minidump generation
// to happen properly.
return true;
}
{
PageAllocator allocator;
ProcCpuInfoReader* const reader =
new(allocator) ProcCpuInfoReader(fd);
const char* field;
while (reader->GetNextField(&field)) {
for (size_t i = 0;
i < sizeof(cpu_id_entries)/sizeof(cpu_id_entries[0]);
++i) {
const CpuIdEntry* entry = &cpu_id_entries[i];
if (my_strcmp(entry->field, field) != 0)
continue;
uintptr_t result = 0;
const char* value = reader->GetValue();
const char* p = value;
if (value[0] == '0' && value[1] == 'x') {
p = my_read_hex_ptr(&result, value+2);
} else if (entry->format == 'x') {
p = my_read_hex_ptr(&result, value);
} else {
p = my_read_decimal_ptr(&result, value);
}
if (p == value)
continue;
result &= (1U << entry->bit_length)-1;
result <<= entry->bit_lshift;
sys_info->cpu.arm_cpu_info.cpuid |=
static_cast<uint32_t>(result);
}
#if defined(__arm__)
// Get the architecture version from the "Processor" field.
// Note that it is also available in the "CPU architecture" field,
// however, some existing kernels are misconfigured and will report
// invalid values here (e.g. 6, while the CPU is ARMv7-A based).
// The "Processor" field doesn't have this issue.
if (!my_strcmp(field, "Processor")) {
size_t value_len;
const char* value = reader->GetValueAndLen(&value_len);
// Expected format: <text> (v<level><endian>)
// Where <text> is some text like "ARMv7 Processor rev 2"
// and <level> is a decimal corresponding to the ARM
// architecture number. <endian> is either 'l' or 'b'
// and corresponds to the endianess, it is ignored here.
while (value_len > 0 && my_isspace(value[value_len-1]))
value_len--;
size_t nn = value_len;
while (nn > 0 && value[nn-1] != '(')
nn--;
if (nn > 0 && value[nn] == 'v') {
uintptr_t arch_level = 5;
my_read_decimal_ptr(&arch_level, value + nn + 1);
sys_info->processor_level = static_cast<uint16_t>(arch_level);
}
}
#elif defined(__aarch64__)
// The aarch64 architecture does not provide the architecture level
// in the Processor field, so we instead check the "CPU architecture"
// field.
if (!my_strcmp(field, "CPU architecture")) {
uintptr_t arch_level = 0;
const char* value = reader->GetValue();
const char* p = value;
p = my_read_decimal_ptr(&arch_level, value);
if (p == value)
continue;
sys_info->processor_level = static_cast<uint16_t>(arch_level);
}
#endif
// Rebuild the ELF hwcaps from the 'Features' field.
if (!my_strcmp(field, "Features")) {
size_t value_len;
const char* value = reader->GetValueAndLen(&value_len);
// Parse each space-separated tag.
while (value_len > 0) {
const char* tag = value;
size_t tag_len = value_len;
const char* p = my_strchr(tag, ' ');
if (p != NULL) {
tag_len = static_cast<size_t>(p - tag);
value += tag_len + 1;
value_len -= tag_len + 1;
} else {
tag_len = strlen(tag);
value_len = 0;
}
for (size_t i = 0;
i < sizeof(cpu_features_entries)/
sizeof(cpu_features_entries[0]);
++i) {
const CpuFeaturesEntry* entry = &cpu_features_entries[i];
if (tag_len == strlen(entry->tag) &&
!memcmp(tag, entry->tag, tag_len)) {
sys_info->cpu.arm_cpu_info.elf_hwcaps |= entry->hwcaps;
break;
}
}
}
}
}
sys_close(fd);
}
return true;
}
#else
# error "Unsupported CPU"
#endif
bool WriteFile(MDLocationDescriptor* result, const char* filename) {
const int fd = sys_open(filename, O_RDONLY, 0);
if (fd < 0)
return false;
// We can't stat the files because several of the files that we want to
// read are kernel seqfiles, which always have a length of zero. So we have
// to read as much as we can into a buffer.
static const unsigned kBufSize = 1024 - 2*sizeof(void*);
struct Buffers {
Buffers* next;
size_t len;
uint8_t data[kBufSize];
} *buffers = reinterpret_cast<Buffers*>(Alloc(sizeof(Buffers)));
buffers->next = NULL;
buffers->len = 0;
size_t total = 0;
for (Buffers* bufptr = buffers;;) {
ssize_t r;
do {
r = sys_read(fd, &bufptr->data[bufptr->len], kBufSize - bufptr->len);
} while (r == -1 && errno == EINTR);
if (r < 1)
break;
total += r;
bufptr->len += r;
if (bufptr->len == kBufSize) {
bufptr->next = reinterpret_cast<Buffers*>(Alloc(sizeof(Buffers)));
bufptr = bufptr->next;
bufptr->next = NULL;
bufptr->len = 0;
}
}
sys_close(fd);
if (!total)
return false;
UntypedMDRVA memory(&minidump_writer_);
if (!memory.Allocate(total))
return false;
for (MDRVA pos = memory.position(); buffers; buffers = buffers->next) {
// Check for special case of a zero-length buffer. This should only
// occur if a file's size happens to be a multiple of the buffer's
// size, in which case the final sys_read() will have resulted in
// zero bytes being read after the final buffer was just allocated.
if (buffers->len == 0) {
// This can only occur with final buffer.
assert(buffers->next == NULL);
continue;
}
memory.Copy(pos, &buffers->data, buffers->len);
pos += buffers->len;
}
*result = memory.location();
return true;
}
bool WriteOSInformation(MDRawSystemInfo* sys_info) {
#if defined(__ANDROID__)
sys_info->platform_id = MD_OS_ANDROID;
#else
sys_info->platform_id = MD_OS_LINUX;
#endif
struct utsname uts;
if (uname(&uts))
return false;
static const size_t buf_len = 512;
char buf[buf_len] = {0};
size_t space_left = buf_len - 1;
const char* info_table[] = {
uts.sysname,
uts.release,
uts.version,
uts.machine,
NULL
};
bool first_item = true;
for (const char** cur_info = info_table; *cur_info; cur_info++) {
static const char separator[] = " ";
size_t separator_len = sizeof(separator) - 1;
size_t info_len = my_strlen(*cur_info);
if (info_len == 0)
continue;
if (space_left < info_len + (first_item ? 0 : separator_len))
break;
if (!first_item) {
my_strlcat(buf, separator, sizeof(buf));
space_left -= separator_len;
}
first_item = false;
my_strlcat(buf, *cur_info, sizeof(buf));
space_left -= info_len;
}
MDLocationDescriptor location;
if (!minidump_writer_.WriteString(buf, 0, &location))
return false;
sys_info->csd_version_rva = location.rva;
return true;
}
bool WriteProcFile(MDLocationDescriptor* result, pid_t pid,
const char* filename) {
char buf[NAME_MAX];
if (!dumper_->BuildProcPath(buf, pid, filename))
return false;
return WriteFile(result, buf);
}
// Only one of the 2 member variables below should be set to a valid value.
const int fd_; // File descriptor where the minidum should be written.
const char* path_; // Path to the file where the minidum should be written.
const struct ucontext* const ucontext_; // also from the signal handler
#if !defined(__ARM_EABI__) && !defined(__mips__)
const google_breakpad::fpstate_t* const float_state_; // ditto
#endif
LinuxDumper* dumper_;
MinidumpFileWriter minidump_writer_;
off_t minidump_size_limit_;
MDLocationDescriptor crashing_thread_context_;
// Blocks of memory written to the dump. These are all currently
// written while writing the thread list stream, but saved here
// so a memory list stream can be written afterwards.
wasteful_vector<MDMemoryDescriptor> memory_blocks_;
// Additional information about some mappings provided by the caller.
const MappingList& mapping_list_;
// Additional memory regions to be included in the dump,
// provided by the caller.
const AppMemoryList& app_memory_list_;
};
bool WriteMinidumpImpl(const char* minidump_path,
int minidump_fd,
off_t minidump_size_limit,
pid_t crashing_process,
const void* blob, size_t blob_size,
const MappingList& mappings,
const AppMemoryList& appmem) {
LinuxPtraceDumper dumper(crashing_process);
const ExceptionHandler::CrashContext* context = NULL;
if (blob) {
if (blob_size != sizeof(ExceptionHandler::CrashContext))
return false;
context = reinterpret_cast<const ExceptionHandler::CrashContext*>(blob);
dumper.set_crash_address(
reinterpret_cast<uintptr_t>(context->siginfo.si_addr));
dumper.set_crash_signal(context->siginfo.si_signo);
dumper.set_crash_thread(context->tid);
}
MinidumpWriter writer(minidump_path, minidump_fd, context, mappings,
appmem, &dumper);
// Set desired limit for file size of minidump (-1 means no limit).
writer.set_minidump_size_limit(minidump_size_limit);
if (!writer.Init())
return false;
return writer.Dump();
}
} // namespace
namespace google_breakpad {
bool WriteMinidump(const char* minidump_path, pid_t crashing_process,
const void* blob, size_t blob_size) {
return WriteMinidumpImpl(minidump_path, -1, -1,
crashing_process, blob, blob_size,
MappingList(), AppMemoryList());
}
bool WriteMinidump(int minidump_fd, pid_t crashing_process,
const void* blob, size_t blob_size) {
return WriteMinidumpImpl(NULL, minidump_fd, -1,
crashing_process, blob, blob_size,
MappingList(), AppMemoryList());
}
bool WriteMinidump(const char* minidump_path, pid_t process,
pid_t process_blamed_thread) {
LinuxPtraceDumper dumper(process);
// MinidumpWriter will set crash address
dumper.set_crash_signal(MD_EXCEPTION_CODE_LIN_DUMP_REQUESTED);
dumper.set_crash_thread(process_blamed_thread);
MinidumpWriter writer(minidump_path, -1, NULL, MappingList(),
AppMemoryList(), &dumper);
if (!writer.Init())
return false;
return writer.Dump();
}
bool WriteMinidump(const char* minidump_path, pid_t crashing_process,
const void* blob, size_t blob_size,
const MappingList& mappings,
const AppMemoryList& appmem) {
return WriteMinidumpImpl(minidump_path, -1, -1, crashing_process,
blob, blob_size,
mappings, appmem);
}
bool WriteMinidump(int minidump_fd, pid_t crashing_process,
const void* blob, size_t blob_size,
const MappingList& mappings,
const AppMemoryList& appmem) {
return WriteMinidumpImpl(NULL, minidump_fd, -1, crashing_process,
blob, blob_size,
mappings, appmem);
}
bool WriteMinidump(const char* minidump_path, off_t minidump_size_limit,
pid_t crashing_process,
const void* blob, size_t blob_size,
const MappingList& mappings,
const AppMemoryList& appmem) {
return WriteMinidumpImpl(minidump_path, -1, minidump_size_limit,
crashing_process, blob, blob_size,
mappings, appmem);
}
bool WriteMinidump(int minidump_fd, off_t minidump_size_limit,
pid_t crashing_process,
const void* blob, size_t blob_size,
const MappingList& mappings,
const AppMemoryList& appmem) {
return WriteMinidumpImpl(NULL, minidump_fd, minidump_size_limit,
crashing_process, blob, blob_size,
mappings, appmem);
}
bool WriteMinidump(const char* filename,
const MappingList& mappings,
const AppMemoryList& appmem,
LinuxDumper* dumper) {
MinidumpWriter writer(filename, -1, NULL, mappings, appmem, dumper);
if (!writer.Init())
return false;
return writer.Dump();
}
} // namespace google_breakpad
| 36.343567 | 80 | 0.644073 | zzilla |
4b1ee7b06f3ef093fccc4eb7f9c2fb4ddc8cc842 | 4,049 | cpp | C++ | RoguelikeGame.Main/Engine/Managers/TexturesManager.cpp | VegetaTheKing/RoguelikeGame | 74036ad8857da961a490dd73d8bb2a5fbef88e39 | [
"MIT"
] | null | null | null | RoguelikeGame.Main/Engine/Managers/TexturesManager.cpp | VegetaTheKing/RoguelikeGame | 74036ad8857da961a490dd73d8bb2a5fbef88e39 | [
"MIT"
] | null | null | null | RoguelikeGame.Main/Engine/Managers/TexturesManager.cpp | VegetaTheKing/RoguelikeGame | 74036ad8857da961a490dd73d8bb2a5fbef88e39 | [
"MIT"
] | null | null | null | #include "TexturesManager.h"
TexturesManager::TexturesManager()
{
_logger = Logger::GetInstance();
}
void TexturesManager::LoadFromFile(const std::string& name, const std::string& path, const sf::IntRect& area)
{
std::string message = " graphics No" + std::to_string(_textures.size() + 1) + " (" + name + ") from \"" + path + "\"";
if (_textures[name].loadFromFile(path, area) == false)
_logger->Log(Logger::LogType::ERROR, "Unable to load" + message);
else
_logger->Log(Logger::LogType::INFO, "Loaded" + message);
}
void TexturesManager::LoadFromImage(const std::string& name, const sf::Image& img, const sf::IntRect& area)
{
std::string message = " graphics No" + std::to_string(_textures.size() + 1) + " (" + name + ") from image";
if (_textures[name].loadFromImage(img, area) == false)
_logger->Log(Logger::LogType::ERROR, "Unable to load" + message);
else
_logger->Log(Logger::LogType::INFO, "Loaded" + message);
}
void TexturesManager::LoadFromMemory(const std::string& name, const void* data, size_t size, const sf::IntRect& area)
{
std::string message = " graphics No" + std::to_string(_textures.size() + 1) + " (" + name + ") from memory";
if (_textures[name].loadFromMemory(data, size, area) == false)
_logger->Log(Logger::LogType::ERROR, "Unable to load" + message);
else
_logger->Log(Logger::LogType::INFO, "Loaded" + message);
}
void TexturesManager::LoadFromStream(const std::string& name, sf::InputStream& stream, const sf::IntRect& area)
{
std::string message = " graphics No" + std::to_string(_textures.size() + 1) + " (" + name + ") from stream";
if (_textures[name].loadFromStream(stream, area) == false)
_logger->Log(Logger::LogType::ERROR, "Unable to load" + message);
else
_logger->Log(Logger::LogType::INFO, "Loaded" + message);
}
std::shared_ptr<sf::Texture> TexturesManager::CreateTmpTexture(const std::string& name, const std::string& source, const sf::IntRect& area)
{
auto found = _tmpTextures.find(name);
if (found != _tmpTextures.end() && found->second.use_count() > 1)
return nullptr;
auto tex = GetTexture(source);
if (tex == nullptr)
return nullptr;
auto srcSize = tex->getSize();
if (CollisionHelper::CheckRectContains(sf::IntRect(0, 0, int(srcSize.x), int(srcSize.y)), area) == false)
return nullptr;
//Find first with use_count <= 1
std::shared_ptr<sf::Texture> empty = nullptr;
for(auto it = _tmpTextures.begin(); it != _tmpTextures.end(); it++)
{
if (it->second.use_count() <= 1)
{
if (it->second == nullptr)
{
_tmpTextures.erase(it->first);
continue;
}
else
{
it->second.swap(empty);
_tmpTextures.erase(it->first);
break;
}
}
}
//Convert
auto img = tex->copyToImage();
if (empty == nullptr)
empty = std::make_shared<sf::Texture>();
if (empty->loadFromImage(img, area) == false)
return nullptr;
_tmpTextures[name] = empty;
return _tmpTextures[name];
}
sf::Texture* TexturesManager::GetTexture(const std::string& name)
{
auto found = _textures.find(name);
if (found != _textures.end())
return &((*found).second);
else
return nullptr;
}
std::shared_ptr<sf::Texture> TexturesManager::GetTmpTexture(const std::string& name)
{
auto found = _tmpTextures.find(name);
if (found != _tmpTextures.end())
{
if (found->second.use_count() > 1)
return found->second;
else
return nullptr;
}
return nullptr;
}
bool TexturesManager::Exists(const std::string& name) const
{
if (_textures.find(name) != _textures.end())
return true;
return false;
}
bool TexturesManager::TmpExists(const std::string& name) const
{
auto found = _tmpTextures.find(name);
if (found != _tmpTextures.end())
{
if (found->second.use_count() > 1)
return true;
else
return false;
}
return false;
}
void TexturesManager::ApplySmooth(bool smooth)
{
for (auto it = _textures.begin(); it != _textures.end(); it++)
it->second.setSmooth(smooth);
}
void TexturesManager::ApplyRepeat(bool repeat)
{
for (auto it = _textures.begin(); it != _textures.end(); it++)
it->second.setRepeated(repeat);
}
| 27.732877 | 139 | 0.676216 | VegetaTheKing |
4b205b7d8d48fed0697c204ff48ac4ab3f10ce93 | 658 | hh | C++ | include/HistoManager.hh | ggonei/nanostructures4scintillators | 5f3f551b6086e438db68f61d50ed1203d416e778 | [
"MIT"
] | null | null | null | include/HistoManager.hh | ggonei/nanostructures4scintillators | 5f3f551b6086e438db68f61d50ed1203d416e778 | [
"MIT"
] | null | null | null | include/HistoManager.hh | ggonei/nanostructures4scintillators | 5f3f551b6086e438db68f61d50ed1203d416e778 | [
"MIT"
] | null | null | null | //
// George O'Neill, University of York 2020
//
// Make a basic cube that allows for addition of photonic objects
//
// This defines histograms we are filling
//
#ifndef HistoManager_h
#define HistoManager_h 1
#define VERBOSE 1
#include <g4root.hh> // change this for different types of files
#include <G4UnitsTable.hh>
#include <globals.hh>
class HistoManager{
public:
HistoManager(): fFileName( "n4s_histos" ){
Book();
}; // default constructor
~HistoManager(){
delete G4AnalysisManager::Instance();
}; // default destructor
private:
void Book(); // histogram collection
G4String fFileName; // root file name
}; // end HistoManager
#endif | 20.5625 | 66 | 0.724924 | ggonei |
4b218b0ad86a62aa94fc5fe0c4cedead3e00e16f | 1,511 | cpp | C++ | GameServer/Bullet.cpp | Chr157i4n/OpenGL_Space_Game | b4cd4ab65385337c37f26af641597c5fc9126f04 | [
"MIT"
] | 3 | 2020-08-05T00:02:30.000Z | 2021-08-23T00:41:24.000Z | GameServer/Bullet.cpp | Chr157i4n/OpenGL_Space_Game | b4cd4ab65385337c37f26af641597c5fc9126f04 | [
"MIT"
] | null | null | null | GameServer/Bullet.cpp | Chr157i4n/OpenGL_Space_Game | b4cd4ab65385337c37f26af641597c5fc9126f04 | [
"MIT"
] | 2 | 2021-07-03T19:32:08.000Z | 2021-08-19T18:48:52.000Z | #include "Bullet.h"
#include "Game.h"
Bullet::Bullet(glm::vec3 position, glm::vec3 rotation, glm::vec3 direction) : Object("arrow.bmf")
{
this->setType(ObjectType::Object_Bullet);
this->position = position;
this->rotation = rotation;
this->movement = glm::normalize(direction) * speed;
this->name = "Bullet";
this->setCollisionBoxType(CollisionBoxType::cube);
}
void Bullet::fall()
{
this->Object::fall();
if (movement == glm::vec3(0, 0, 0)) return;
if (position.y < 0.5) { movement=glm::vec3(0, 0, 0); return; }
float gegk = movement.y;
float ank = sqrt(pow(movement.x, 2) + pow(movement.z, 2));
rotation.z = atan(gegk / ank) * 180 / 3.14;
rotation.z += 270;
}
void Bullet::checkHit()
{
if (movement.x == 0 && movement.z == 0) return;
CollisionResult collisionresult = checkCollision(); //doubled with the normal collision detection. this can be improved
if (!collisionresult.collided) return;
for (CollidedObject* collidedObject : collisionresult.collidedObjectList)
{
if (collidedObject->object->getType() == ObjectType::Object_Bullet) return;
if (collidedObject->object->getType() == ObjectType::Object_Environment) return;
//if (collidedObject->object->getType() == ObjectType::Object_Player) return;
if (collidedObject->object->getType() == ObjectType::Object_Entity) return;
this->registerHit();
collidedObject->object->registerHit();
Logger::log(collidedObject->object->printObject() + " was hit");
}
}
void Bullet::registerHit()
{
this->health = 0;
}
| 25.610169 | 120 | 0.696889 | Chr157i4n |
4b242cab08417adf39f8783383d9f9182bea52bd | 1,061 | cpp | C++ | lightoj/1111.cpp | cosmicray001/Online_judge_Solutions- | 5dc6f90d3848eb192e6edea8e8c731f41a1761dd | [
"MIT"
] | 3 | 2018-01-08T02:52:51.000Z | 2021-03-03T01:08:44.000Z | lightoj/1111.cpp | cosmicray001/Online_judge_Solutions- | 5dc6f90d3848eb192e6edea8e8c731f41a1761dd | [
"MIT"
] | null | null | null | lightoj/1111.cpp | cosmicray001/Online_judge_Solutions- | 5dc6f90d3848eb192e6edea8e8c731f41a1761dd | [
"MIT"
] | 1 | 2020-08-13T18:07:35.000Z | 2020-08-13T18:07:35.000Z | #include <bits/stdc++.h>
using namespace std;
#define le 1003
vector <int> v[le];
vector<int> ct;
int dis[le];
bool vis[le];
void bfs(int a){
memset(vis, false, sizeof(vis));
vis[a] = true;
dis[a]++;
queue<int> q;
q.push(a);
while(!q.empty()){
int p = q.front();
q.pop();
for(int i = 0; i < v[p].size(); i++){
int e = v[p][i];
if(vis[e] == false){
vis[e] = true;
dis[e]++;
q.push(e);
}
}
}
}
int main(){
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
int t, k, n, m, a, b, co = 0;
for(scanf("%d", &t); t--; ){
scanf("%d %d %d", &k, &n, &m);
for(int i = 0; i < le; dis[i] = 0, v[i].clear(), i++);
for(int i = 0; i < k; scanf("%d", &a), ct.push_back(a), i++);
for(int i = 0; i < m; scanf("%d %d", &a, &b), v[a].push_back(b), i++);
for(int i = 0; i < ct.size(); bfs(ct[i]), i++);
int ans = 0;
for(int i = 1; i < n + 1; i++) if(dis[i] == ct.size()) ans++;
printf("Case %d: %d\n", ++co, ans);
ct.clear();
}
return 0;
}
| 24.113636 | 74 | 0.454288 | cosmicray001 |
4b270364a68fee334fa4684c73572e79b7fb7407 | 19,303 | cpp | C++ | src/core/movie/ffmpeg/AEUtil.cpp | A29586a/Kirikiroid2 | 7871cf9b393453f4b8c8b6f0e6ac1f3c24cdcf7f | [
"BSD-3-Clause"
] | 22 | 2020-01-14T19:19:05.000Z | 2021-09-11T14:06:56.000Z | src/core/movie/ffmpeg/AEUtil.cpp | A29586a/Kirikiroid2 | 7871cf9b393453f4b8c8b6f0e6ac1f3c24cdcf7f | [
"BSD-3-Clause"
] | 3 | 2020-06-07T16:28:26.000Z | 2021-11-11T09:31:27.000Z | src/core/movie/ffmpeg/AEUtil.cpp | A29586a/Kirikiroid2 | 7871cf9b393453f4b8c8b6f0e6ac1f3c24cdcf7f | [
"BSD-3-Clause"
] | 6 | 2020-10-11T13:36:56.000Z | 2021-11-13T06:32:14.000Z | #ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#endif
#if (defined HAVE_CONFIG_H) && (!defined TARGET_WINDOWS)
#include "config.h"
#endif
#include "AEUtil.h"
#include "TimeUtils.h"
#include <cassert>
extern "C" {
#include "libavutil/channel_layout.h"
}
NS_KRMOVIE_BEGIN
/* declare the rng seed and initialize it */
unsigned int CAEUtil::m_seed = (unsigned int)(CurrentHostCounter() / 1000.0f);
#if defined(HAVE_SSE2) && defined(__SSE2__)
/* declare the SSE seed and initialize it */
MEMALIGN(16, __m128i CAEUtil::m_sseSeed) = _mm_set_epi32(CAEUtil::m_seed, CAEUtil::m_seed+1, CAEUtil::m_seed, CAEUtil::m_seed+1);
#endif
void AEDelayStatus::SetDelay(double d)
{
delay = d;
maxcorrection = d;
tick = CurrentHostCounter();
}
double AEDelayStatus::GetDelay()
{
double d = 0;
if (tick)
d = (double)(CurrentHostCounter() - tick) / CurrentHostFrequency();
if (d > maxcorrection)
d = maxcorrection;
return delay - d;
}
#if 0
CAEChannelInfo CAEUtil::GuessChLayout(const unsigned int channels)
{
CLog::Log(LOGWARNING, "CAEUtil::GuessChLayout - "
"This method should really never be used, please fix the code that called this");
CAEChannelInfo result;
if (channels < 1 || channels > 8)
return result;
switch (channels)
{
case 1: result = AE_CH_LAYOUT_1_0; break;
case 2: result = AE_CH_LAYOUT_2_0; break;
case 3: result = AE_CH_LAYOUT_3_0; break;
case 4: result = AE_CH_LAYOUT_4_0; break;
case 5: result = AE_CH_LAYOUT_5_0; break;
case 6: result = AE_CH_LAYOUT_5_1; break;
case 7: result = AE_CH_LAYOUT_7_0; break;
case 8: result = AE_CH_LAYOUT_7_1; break;
}
return result;
}
#endif
const char* CAEUtil::GetStdChLayoutName(const enum AEStdChLayout layout)
{
if (layout < 0 || layout >= AE_CH_LAYOUT_MAX)
return "UNKNOWN";
static const char* layouts[AE_CH_LAYOUT_MAX] =
{
"1.0",
"2.0", "2.1", "3.0", "3.1", "4.0",
"4.1", "5.0", "5.1", "7.0", "7.1"
};
return layouts[layout];
}
const unsigned int CAEUtil::DataFormatToBits(const enum AEDataFormat dataFormat)
{
if (dataFormat < 0 || dataFormat >= AE_FMT_MAX)
return 0;
static const unsigned int formats[AE_FMT_MAX] =
{
8, /* U8 */
16, /* S16BE */
16, /* S16LE */
16, /* S16NE */
32, /* S32BE */
32, /* S32LE */
32, /* S32NE */
32, /* S24BE */
32, /* S24LE */
32, /* S24NE */
32, /* S24NER */
24, /* S24BE3 */
24, /* S24LE3 */
24, /* S24NE3 */
sizeof(double) << 3, /* DOUBLE */
sizeof(float ) << 3, /* FLOAT */
8, /* RAW */
8, /* U8P */
16, /* S16NEP */
32, /* S32NEP */
32, /* S24NEP */
32, /* S24NERP*/
24, /* S24NE3P*/
sizeof(double) << 3, /* DOUBLEP */
sizeof(float ) << 3 /* FLOATP */
};
return formats[dataFormat];
}
const unsigned int CAEUtil::DataFormatToUsedBits(const enum AEDataFormat dataFormat)
{
if (dataFormat == AE_FMT_S24BE4 || dataFormat == AE_FMT_S24LE4 ||
dataFormat == AE_FMT_S24NE4 || dataFormat == AE_FMT_S24NE4MSB)
return 24;
else
return DataFormatToBits(dataFormat);
}
const unsigned int CAEUtil::DataFormatToDitherBits(const enum AEDataFormat dataFormat)
{
if (dataFormat == AE_FMT_S24NE4MSB)
return 8;
if (dataFormat == AE_FMT_S24NE3)
return -8;
else
return 0;
}
const char* CAEUtil::StreamTypeToStr(const enum CAEStreamInfo::DataType dataType)
{
switch (dataType)
{
case CAEStreamInfo::STREAM_TYPE_AC3:
return "STREAM_TYPE_AC3";
case CAEStreamInfo::STREAM_TYPE_DTSHD:
return "STREAM_TYPE_DTSHD";
case CAEStreamInfo::STREAM_TYPE_DTSHD_CORE:
return "STREAM_TYPE_DTSHD_CORE";
case CAEStreamInfo::STREAM_TYPE_DTS_1024:
return "STREAM_TYPE_DTS_1024";
case CAEStreamInfo::STREAM_TYPE_DTS_2048:
return "STREAM_TYPE_DTS_2048";
case CAEStreamInfo::STREAM_TYPE_DTS_512:
return "STREAM_TYPE_DTS_512";
case CAEStreamInfo::STREAM_TYPE_EAC3:
return "STREAM_TYPE_EAC3";
case CAEStreamInfo::STREAM_TYPE_MLP:
return "STREAM_TYPE_MLP";
case CAEStreamInfo::STREAM_TYPE_TRUEHD:
return "STREAM_TYPE_TRUEHD";
default:
return "STREAM_TYPE_NULL";
}
}
const char* CAEUtil::DataFormatToStr(const enum AEDataFormat dataFormat)
{
if (dataFormat < 0 || dataFormat >= AE_FMT_MAX)
return "UNKNOWN";
static const char *formats[AE_FMT_MAX] =
{
"AE_FMT_U8",
"AE_FMT_S16BE",
"AE_FMT_S16LE",
"AE_FMT_S16NE",
"AE_FMT_S32BE",
"AE_FMT_S32LE",
"AE_FMT_S32NE",
"AE_FMT_S24BE4",
"AE_FMT_S24LE4",
"AE_FMT_S24NE4", /* S24 in 4 bytes */
"AE_FMT_S24NE4MSB",
"AE_FMT_S24BE3",
"AE_FMT_S24LE3",
"AE_FMT_S24NE3", /* S24 in 3 bytes */
"AE_FMT_DOUBLE",
"AE_FMT_FLOAT",
"AE_FMT_RAW",
/* planar formats */
"AE_FMT_U8P",
"AE_FMT_S16NEP",
"AE_FMT_S32NEP",
"AE_FMT_S24NE4P",
"AE_FMT_S24NE4MSBP",
"AE_FMT_S24NE3P",
"AE_FMT_DOUBLEP",
"AE_FMT_FLOATP"
};
return formats[dataFormat];
}
#if defined(HAVE_SSE) && defined(__SSE__)
void CAEUtil::SSEMulArray(float *data, const float mul, uint32_t count)
{
const __m128 m = _mm_set_ps1(mul);
/* work around invalid alignment */
while (((uintptr_t)data & 0xF) && count > 0)
{
data[0] *= mul;
++data;
--count;
}
uint32_t even = count & ~0x3;
for (uint32_t i = 0; i < even; i+=4, data+=4)
{
__m128 to = _mm_load_ps(data);
*(__m128*)data = _mm_mul_ps (to, m);
}
if (even != count)
{
uint32_t odd = count - even;
if (odd == 1)
data[0] *= mul;
else
{
__m128 to;
if (odd == 2)
{
to = _mm_setr_ps(data[0], data[1], 0, 0);
__m128 ou = _mm_mul_ps(to, m);
data[0] = ((float*)&ou)[0];
data[1] = ((float*)&ou)[1];
}
else
{
to = _mm_setr_ps(data[0], data[1], data[2], 0);
__m128 ou = _mm_mul_ps(to, m);
data[0] = ((float*)&ou)[0];
data[1] = ((float*)&ou)[1];
data[2] = ((float*)&ou)[2];
}
}
}
}
void CAEUtil::SSEMulAddArray(float *data, float *add, const float mul, uint32_t count)
{
const __m128 m = _mm_set_ps1(mul);
/* work around invalid alignment */
while ((((uintptr_t)data & 0xF) || ((uintptr_t)add & 0xF)) && count > 0)
{
data[0] += add[0] * mul;
++add;
++data;
--count;
}
uint32_t even = count & ~0x3;
for (uint32_t i = 0; i < even; i+=4, data+=4, add+=4)
{
__m128 ad = _mm_load_ps(add );
__m128 to = _mm_load_ps(data);
*(__m128*)data = _mm_add_ps (to, _mm_mul_ps(ad, m));
}
if (even != count)
{
uint32_t odd = count - even;
if (odd == 1)
data[0] += add[0] * mul;
else
{
__m128 ad;
__m128 to;
if (odd == 2)
{
ad = _mm_setr_ps(add [0], add [1], 0, 0);
to = _mm_setr_ps(data[0], data[1], 0, 0);
__m128 ou = _mm_add_ps(to, _mm_mul_ps(ad, m));
data[0] = ((float*)&ou)[0];
data[1] = ((float*)&ou)[1];
}
else
{
ad = _mm_setr_ps(add [0], add [1], add [2], 0);
to = _mm_setr_ps(data[0], data[1], data[2], 0);
__m128 ou = _mm_add_ps(to, _mm_mul_ps(ad, m));
data[0] = ((float*)&ou)[0];
data[1] = ((float*)&ou)[1];
data[2] = ((float*)&ou)[2];
}
}
}
}
#endif
inline float CAEUtil::SoftClamp(const float x)
{
#if 1
/*
This is a rational function to approximate a tanh-like soft clipper.
It is based on the pade-approximation of the tanh function with tweaked coefficients.
See: http://www.musicdsp.org/showone.php?id=238
*/
if (x < -3.0f)
return -1.0f;
else if (x > 3.0f)
return 1.0f;
float y = x * x;
return x * (27.0f + y) / (27.0f + 9.0f * y);
#else
/* slower method using tanh, but more accurate */
static const double k = 0.9f;
/* perform a soft clamp */
if (x > k)
x = (float) (tanh((x - k) / (1 - k)) * (1 - k) + k);
else if (x < -k)
x = (float) (tanh((x + k) / (1 - k)) * (1 - k) - k);
/* hard clamp anything still outside the bounds */
if (x > 1.0f)
return 1.0f;
if (x < -1.0f)
return -1.0f;
/* return the final sample */
return x;
#endif
}
void CAEUtil::ClampArray(float *data, uint32_t count)
{
#if !defined(HAVE_SSE) || !defined(__SSE__)
for (uint32_t i = 0; i < count; ++i)
data[i] = SoftClamp(data[i]);
#else
const __m128 c1 = _mm_set_ps1(27.0f);
const __m128 c2 = _mm_set_ps1(27.0f + 9.0f);
/* work around invalid alignment */
while (((uintptr_t)data & 0xF) && count > 0)
{
data[0] = SoftClamp(data[0]);
++data;
--count;
}
uint32_t even = count & ~0x3;
for (uint32_t i = 0; i < even; i+=4, data+=4)
{
/* tanh approx clamp */
__m128 dt = _mm_load_ps(data);
__m128 tmp = _mm_mul_ps(dt, dt);
*(__m128*)data = _mm_div_ps(
_mm_mul_ps(
dt,
_mm_add_ps(c1, tmp)
),
_mm_add_ps(c2, tmp)
);
}
if (even != count)
{
uint32_t odd = count - even;
if (odd == 1)
data[0] = SoftClamp(data[0]);
else
{
__m128 dt;
__m128 tmp;
__m128 out;
if (odd == 2)
{
/* tanh approx clamp */
dt = _mm_setr_ps(data[0], data[1], 0, 0);
tmp = _mm_mul_ps(dt, dt);
out = _mm_div_ps(
_mm_mul_ps(
dt,
_mm_add_ps(c1, tmp)
),
_mm_add_ps(c2, tmp)
);
data[0] = ((float*)&out)[0];
data[1] = ((float*)&out)[1];
}
else
{
/* tanh approx clamp */
dt = _mm_setr_ps(data[0], data[1], data[2], 0);
tmp = _mm_mul_ps(dt, dt);
out = _mm_div_ps(
_mm_mul_ps(
dt,
_mm_add_ps(c1, tmp)
),
_mm_add_ps(c2, tmp)
);
data[0] = ((float*)&out)[0];
data[1] = ((float*)&out)[1];
data[2] = ((float*)&out)[2];
}
}
}
#endif
}
/*
Rand implementations based on:
http://software.intel.com/en-us/articles/fast-random-number-generator-on-the-intel-pentiumr-4-processor/
This is NOT safe for crypto work, but perfectly fine for audio usage (dithering)
*/
float CAEUtil::FloatRand1(const float min, const float max)
{
const float delta = (max - min) / 2;
const float factor = delta / (float)INT32_MAX;
return ((float)(m_seed = (214013 * m_seed + 2531011)) * factor) - delta;
}
void CAEUtil::FloatRand4(const float min, const float max, float result[4], __m128 *sseresult/* = NULL */)
{
#if defined(HAVE_SSE2) && defined(__SSE2__)
/*
this method may be called from other SSE code, we need
to calculate the delta & factor using SSE as the FPU
state is unknown and _mm_clear() is expensive.
*/
MEMALIGN(16, static const __m128 point5 ) = _mm_set_ps1(0.5f);
MEMALIGN(16, static const __m128 int32max) = _mm_set_ps1((const float)INT32_MAX);
MEMALIGN(16, __m128 f) = _mm_div_ps(
_mm_mul_ps(
_mm_sub_ps(
_mm_set_ps1(max),
_mm_set_ps1(min)
),
point5
),
int32max
);
MEMALIGN(16, __m128i cur_seed_split);
MEMALIGN(16, __m128i multiplier);
MEMALIGN(16, __m128i adder);
MEMALIGN(16, __m128i mod_mask);
MEMALIGN(16, __m128 res);
MEMALIGN(16, static const unsigned int mult [4]) = {214013, 17405, 214013, 69069};
MEMALIGN(16, static const unsigned int gadd [4]) = {2531011, 10395331, 13737667, 1};
MEMALIGN(16, static const unsigned int mask [4]) = {0xFFFFFFFF, 0, 0xFFFFFFFF, 0};
adder = _mm_load_si128((__m128i*)gadd);
multiplier = _mm_load_si128((__m128i*)mult);
mod_mask = _mm_load_si128((__m128i*)mask);
cur_seed_split = _mm_shuffle_epi32(m_sseSeed, _MM_SHUFFLE(2, 3, 0, 1));
m_sseSeed = _mm_mul_epu32(m_sseSeed, multiplier);
multiplier = _mm_shuffle_epi32(multiplier, _MM_SHUFFLE(2, 3, 0, 1));
cur_seed_split = _mm_mul_epu32(cur_seed_split, multiplier);
m_sseSeed = _mm_and_si128(m_sseSeed, mod_mask);
cur_seed_split = _mm_and_si128(cur_seed_split, mod_mask);
cur_seed_split = _mm_shuffle_epi32(cur_seed_split, _MM_SHUFFLE(2, 3, 0, 1));
m_sseSeed = _mm_or_si128(m_sseSeed, cur_seed_split);
m_sseSeed = _mm_add_epi32(m_sseSeed, adder);
/* adjust the value to the range requested */
res = _mm_cvtepi32_ps(m_sseSeed);
if (sseresult)
*sseresult = _mm_mul_ps(res, f);
else
{
res = _mm_mul_ps(res, f);
_mm_storeu_ps(result, res);
/* returning a float array, so cleanup */
_mm_empty();
}
#else
const float delta = (max - min) / 2.0f;
const float factor = delta / (float)INT32_MAX;
/* cant return sseresult if we are not using SSE intrinsics */
assert(result && !sseresult);
result[0] = ((float)(m_seed = (214013 * m_seed + 2531011)) * factor) - delta;
result[1] = ((float)(m_seed = (214013 * m_seed + 2531011)) * factor) - delta;
result[2] = ((float)(m_seed = (214013 * m_seed + 2531011)) * factor) - delta;
result[3] = ((float)(m_seed = (214013 * m_seed + 2531011)) * factor) - delta;
#endif
}
bool CAEUtil::S16NeedsByteSwap(AEDataFormat in, AEDataFormat out)
{
const AEDataFormat nativeFormat =
#ifdef WORDS_BIGENDIAN
AE_FMT_S16BE;
#else
AE_FMT_S16LE;
#endif
if (in == AE_FMT_S16NE || (in == AE_FMT_RAW))
in = nativeFormat;
if (out == AE_FMT_S16NE || (out == AE_FMT_RAW))
out = nativeFormat;
return in != out;
}
uint64_t CAEUtil::GetAVChannelLayout(const CAEChannelInfo &info)
{
uint64_t channelLayout = 0;
if (info.HasChannel(AE_CH_FL)) channelLayout |= AV_CH_FRONT_LEFT;
if (info.HasChannel(AE_CH_FR)) channelLayout |= AV_CH_FRONT_RIGHT;
if (info.HasChannel(AE_CH_FC)) channelLayout |= AV_CH_FRONT_CENTER;
if (info.HasChannel(AE_CH_LFE)) channelLayout |= AV_CH_LOW_FREQUENCY;
if (info.HasChannel(AE_CH_BL)) channelLayout |= AV_CH_BACK_LEFT;
if (info.HasChannel(AE_CH_BR)) channelLayout |= AV_CH_BACK_RIGHT;
if (info.HasChannel(AE_CH_FLOC)) channelLayout |= AV_CH_FRONT_LEFT_OF_CENTER;
if (info.HasChannel(AE_CH_FROC)) channelLayout |= AV_CH_FRONT_RIGHT_OF_CENTER;
if (info.HasChannel(AE_CH_BC)) channelLayout |= AV_CH_BACK_CENTER;
if (info.HasChannel(AE_CH_SL)) channelLayout |= AV_CH_SIDE_LEFT;
if (info.HasChannel(AE_CH_SR)) channelLayout |= AV_CH_SIDE_RIGHT;
if (info.HasChannel(AE_CH_TC)) channelLayout |= AV_CH_TOP_CENTER;
if (info.HasChannel(AE_CH_TFL)) channelLayout |= AV_CH_TOP_FRONT_LEFT;
if (info.HasChannel(AE_CH_TFC)) channelLayout |= AV_CH_TOP_FRONT_CENTER;
if (info.HasChannel(AE_CH_TFR)) channelLayout |= AV_CH_TOP_FRONT_RIGHT;
if (info.HasChannel(AE_CH_TBL)) channelLayout |= AV_CH_TOP_BACK_LEFT;
if (info.HasChannel(AE_CH_TBC)) channelLayout |= AV_CH_TOP_BACK_CENTER;
if (info.HasChannel(AE_CH_TBR)) channelLayout |= AV_CH_TOP_BACK_RIGHT;
return channelLayout;
}
CAEChannelInfo CAEUtil::GetAEChannelLayout(uint64_t layout)
{
CAEChannelInfo channelLayout;
channelLayout.Reset();
if (layout & AV_CH_FRONT_LEFT) channelLayout += AE_CH_FL;
if (layout & AV_CH_FRONT_RIGHT) channelLayout += AE_CH_FR;
if (layout & AV_CH_FRONT_CENTER) channelLayout += AE_CH_FC;
if (layout & AV_CH_LOW_FREQUENCY) channelLayout += AE_CH_LFE;
if (layout & AV_CH_BACK_LEFT) channelLayout += AE_CH_BL;
if (layout & AV_CH_BACK_RIGHT) channelLayout += AE_CH_BR;
if (layout & AV_CH_FRONT_LEFT_OF_CENTER) channelLayout += AE_CH_FLOC;
if (layout & AV_CH_FRONT_RIGHT_OF_CENTER) channelLayout += AE_CH_FROC;
if (layout & AV_CH_BACK_CENTER) channelLayout += AE_CH_BC;
if (layout & AV_CH_SIDE_LEFT) channelLayout += AE_CH_SL;
if (layout & AV_CH_SIDE_RIGHT) channelLayout += AE_CH_SR;
if (layout & AV_CH_TOP_CENTER) channelLayout += AE_CH_TC;
if (layout & AV_CH_TOP_FRONT_LEFT) channelLayout += AE_CH_TFL;
if (layout & AV_CH_TOP_FRONT_CENTER) channelLayout += AE_CH_TFC;
if (layout & AV_CH_TOP_FRONT_RIGHT) channelLayout += AE_CH_TFR;
if (layout & AV_CH_TOP_BACK_LEFT) channelLayout += AE_CH_BL;
if (layout & AV_CH_TOP_BACK_CENTER) channelLayout += AE_CH_BC;
if (layout & AV_CH_TOP_BACK_RIGHT) channelLayout += AE_CH_BR;
return channelLayout;
}
AVSampleFormat CAEUtil::GetAVSampleFormat(AEDataFormat format)
{
switch (format)
{
case AEDataFormat::AE_FMT_U8:
return AV_SAMPLE_FMT_U8;
case AEDataFormat::AE_FMT_S16NE:
return AV_SAMPLE_FMT_S16;
case AEDataFormat::AE_FMT_S32NE:
return AV_SAMPLE_FMT_S32;
case AEDataFormat::AE_FMT_S24NE4:
return AV_SAMPLE_FMT_S32;
case AEDataFormat::AE_FMT_S24NE4MSB:
return AV_SAMPLE_FMT_S32;
case AEDataFormat::AE_FMT_S24NE3:
return AV_SAMPLE_FMT_S32;
case AEDataFormat::AE_FMT_FLOAT:
return AV_SAMPLE_FMT_FLT;
case AEDataFormat::AE_FMT_DOUBLE:
return AV_SAMPLE_FMT_DBL;
case AEDataFormat::AE_FMT_U8P:
return AV_SAMPLE_FMT_U8P;
case AEDataFormat::AE_FMT_S16NEP:
return AV_SAMPLE_FMT_S16P;
case AEDataFormat::AE_FMT_S32NEP:
return AV_SAMPLE_FMT_S32P;
case AEDataFormat::AE_FMT_S24NE4P:
return AV_SAMPLE_FMT_S32P;
case AEDataFormat::AE_FMT_S24NE4MSBP:
return AV_SAMPLE_FMT_S32P;
case AEDataFormat::AE_FMT_S24NE3P:
return AV_SAMPLE_FMT_S32P;
case AEDataFormat::AE_FMT_FLOATP:
return AV_SAMPLE_FMT_FLTP;
case AEDataFormat::AE_FMT_DOUBLEP:
return AV_SAMPLE_FMT_DBLP;
case AEDataFormat::AE_FMT_RAW:
return AV_SAMPLE_FMT_U8;
default:
{
if (AE_IS_PLANAR(format))
return AV_SAMPLE_FMT_FLTP;
else
return AV_SAMPLE_FMT_FLT;
}
}
}
uint64_t CAEUtil::GetAVChannel(enum AEChannel aechannel)
{
switch (aechannel)
{
case AE_CH_FL: return AV_CH_FRONT_LEFT;
case AE_CH_FR: return AV_CH_FRONT_RIGHT;
case AE_CH_FC: return AV_CH_FRONT_CENTER;
case AE_CH_LFE: return AV_CH_LOW_FREQUENCY;
case AE_CH_BL: return AV_CH_BACK_LEFT;
case AE_CH_BR: return AV_CH_BACK_RIGHT;
case AE_CH_FLOC: return AV_CH_FRONT_LEFT_OF_CENTER;
case AE_CH_FROC: return AV_CH_FRONT_RIGHT_OF_CENTER;
case AE_CH_BC: return AV_CH_BACK_CENTER;
case AE_CH_SL: return AV_CH_SIDE_LEFT;
case AE_CH_SR: return AV_CH_SIDE_RIGHT;
case AE_CH_TC: return AV_CH_TOP_CENTER;
case AE_CH_TFL: return AV_CH_TOP_FRONT_LEFT;
case AE_CH_TFC: return AV_CH_TOP_FRONT_CENTER;
case AE_CH_TFR: return AV_CH_TOP_FRONT_RIGHT;
case AE_CH_TBL: return AV_CH_TOP_BACK_LEFT;
case AE_CH_TBC: return AV_CH_TOP_BACK_CENTER;
case AE_CH_TBR: return AV_CH_TOP_BACK_RIGHT;
default:
return 0;
}
}
int CAEUtil::GetAVChannelIndex(enum AEChannel aechannel, uint64_t layout)
{
return av_get_channel_layout_channel_index(layout, GetAVChannel(aechannel));
}
NS_KRMOVIE_END | 29.027068 | 131 | 0.626897 | A29586a |
4b2d2b0d516a824823c24998dc12d7708ee5d8f9 | 109,583 | cpp | C++ | modules/objdetect/src/haar.cpp | gunnjo/opencv | a05ce00a654268f214fcf43e815891a01f7987b5 | [
"BSD-3-Clause"
] | 144 | 2015-01-15T03:38:44.000Z | 2022-02-17T09:07:52.000Z | modules/objdetect/src/haar.cpp | gunnjo/opencv | a05ce00a654268f214fcf43e815891a01f7987b5 | [
"BSD-3-Clause"
] | 9 | 2015-09-09T06:51:46.000Z | 2020-06-17T14:10:10.000Z | modules/objdetect/src/haar.cpp | gunnjo/opencv | a05ce00a654268f214fcf43e815891a01f7987b5 | [
"BSD-3-Clause"
] | 58 | 2015-01-14T23:43:49.000Z | 2021-11-15T05:19:08.000Z | /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// Intel License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's 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.
//
// * The name of Intel Corporation may not 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 Intel Corporation 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.
//
//M*/
/* Haar features calculation */
#include "precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/objdetect/objdetect_c.h"
#include <stdio.h>
#if CV_SSE2
# if 1 /*!CV_SSE4_1 && !CV_SSE4_2*/
# define _mm_blendv_pd(a, b, m) _mm_xor_pd(a, _mm_and_pd(_mm_xor_pd(b, a), m))
# define _mm_blendv_ps(a, b, m) _mm_xor_ps(a, _mm_and_ps(_mm_xor_ps(b, a), m))
# endif
#endif
#if 0 /*CV_AVX*/
# define CV_HAAR_USE_AVX 1
# if defined _MSC_VER
# pragma warning( disable : 4752 )
# endif
#else
# if CV_SSE2
# define CV_HAAR_USE_SSE 1
# endif
#endif
/* these settings affect the quality of detection: change with care */
#define CV_ADJUST_FEATURES 1
#define CV_ADJUST_WEIGHTS 0
typedef int sumtype;
typedef double sqsumtype;
typedef struct CvHidHaarFeature
{
struct
{
sumtype *p0, *p1, *p2, *p3;
float weight;
}
rect[CV_HAAR_FEATURE_MAX];
} CvHidHaarFeature;
typedef struct CvHidHaarTreeNode
{
CvHidHaarFeature feature;
float threshold;
int left;
int right;
} CvHidHaarTreeNode;
typedef struct CvHidHaarClassifier
{
int count;
//CvHaarFeature* orig_feature;
CvHidHaarTreeNode* node;
float* alpha;
} CvHidHaarClassifier;
typedef struct CvHidHaarStageClassifier
{
int count;
float threshold;
CvHidHaarClassifier* classifier;
int two_rects;
struct CvHidHaarStageClassifier* next;
struct CvHidHaarStageClassifier* child;
struct CvHidHaarStageClassifier* parent;
} CvHidHaarStageClassifier;
typedef struct CvHidHaarClassifierCascade
{
int count;
int isStumpBased;
int has_tilted_features;
int is_tree;
double inv_window_area;
CvMat sum, sqsum, tilted;
CvHidHaarStageClassifier* stage_classifier;
sqsumtype *pq0, *pq1, *pq2, *pq3;
sumtype *p0, *p1, *p2, *p3;
void** ipp_stages;
} CvHidHaarClassifierCascade;
const int icv_object_win_border = 1;
const float icv_stage_threshold_bias = 0.0001f;
static CvHaarClassifierCascade*
icvCreateHaarClassifierCascade( int stage_count )
{
CvHaarClassifierCascade* cascade = 0;
int block_size = sizeof(*cascade) + stage_count*sizeof(*cascade->stage_classifier);
if( stage_count <= 0 )
CV_Error( CV_StsOutOfRange, "Number of stages should be positive" );
cascade = (CvHaarClassifierCascade*)cvAlloc( block_size );
memset( cascade, 0, block_size );
cascade->stage_classifier = (CvHaarStageClassifier*)(cascade + 1);
cascade->flags = CV_HAAR_MAGIC_VAL;
cascade->count = stage_count;
return cascade;
}
static void
icvReleaseHidHaarClassifierCascade( CvHidHaarClassifierCascade** _cascade )
{
if( _cascade && *_cascade )
{
#ifdef HAVE_IPP
CvHidHaarClassifierCascade* cascade = *_cascade;
if( cascade->ipp_stages )
{
int i;
for( i = 0; i < cascade->count; i++ )
{
if( cascade->ipp_stages[i] )
ippiHaarClassifierFree_32f( (IppiHaarClassifier_32f*)cascade->ipp_stages[i] );
}
}
cvFree( &cascade->ipp_stages );
#endif
cvFree( _cascade );
}
}
/* create more efficient internal representation of haar classifier cascade */
static CvHidHaarClassifierCascade*
icvCreateHidHaarClassifierCascade( CvHaarClassifierCascade* cascade )
{
CvRect* ipp_features = 0;
float *ipp_weights = 0, *ipp_thresholds = 0, *ipp_val1 = 0, *ipp_val2 = 0;
int* ipp_counts = 0;
CvHidHaarClassifierCascade* out = 0;
int i, j, k, l;
int datasize;
int total_classifiers = 0;
int total_nodes = 0;
char errorstr[1000];
CvHidHaarClassifier* haar_classifier_ptr;
CvHidHaarTreeNode* haar_node_ptr;
CvSize orig_window_size;
int has_tilted_features = 0;
int max_count = 0;
if( !CV_IS_HAAR_CLASSIFIER(cascade) )
CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" );
if( cascade->hid_cascade )
CV_Error( CV_StsError, "hid_cascade has been already created" );
if( !cascade->stage_classifier )
CV_Error( CV_StsNullPtr, "" );
if( cascade->count <= 0 )
CV_Error( CV_StsOutOfRange, "Negative number of cascade stages" );
orig_window_size = cascade->orig_window_size;
/* check input structure correctness and calculate total memory size needed for
internal representation of the classifier cascade */
for( i = 0; i < cascade->count; i++ )
{
CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i;
if( !stage_classifier->classifier ||
stage_classifier->count <= 0 )
{
sprintf( errorstr, "header of the stage classifier #%d is invalid "
"(has null pointers or non-positive classfier count)", i );
CV_Error( CV_StsError, errorstr );
}
max_count = MAX( max_count, stage_classifier->count );
total_classifiers += stage_classifier->count;
for( j = 0; j < stage_classifier->count; j++ )
{
CvHaarClassifier* classifier = stage_classifier->classifier + j;
total_nodes += classifier->count;
for( l = 0; l < classifier->count; l++ )
{
for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ )
{
if( classifier->haar_feature[l].rect[k].r.width )
{
CvRect r = classifier->haar_feature[l].rect[k].r;
int tilted = classifier->haar_feature[l].tilted;
has_tilted_features |= tilted != 0;
if( r.width < 0 || r.height < 0 || r.y < 0 ||
r.x + r.width > orig_window_size.width
||
(!tilted &&
(r.x < 0 || r.y + r.height > orig_window_size.height))
||
(tilted && (r.x - r.height < 0 ||
r.y + r.width + r.height > orig_window_size.height)))
{
sprintf( errorstr, "rectangle #%d of the classifier #%d of "
"the stage classifier #%d is not inside "
"the reference (original) cascade window", k, j, i );
CV_Error( CV_StsNullPtr, errorstr );
}
}
}
}
}
}
// this is an upper boundary for the whole hidden cascade size
datasize = sizeof(CvHidHaarClassifierCascade) +
sizeof(CvHidHaarStageClassifier)*cascade->count +
sizeof(CvHidHaarClassifier) * total_classifiers +
sizeof(CvHidHaarTreeNode) * total_nodes +
sizeof(void*)*(total_nodes + total_classifiers);
out = (CvHidHaarClassifierCascade*)cvAlloc( datasize );
memset( out, 0, sizeof(*out) );
/* init header */
out->count = cascade->count;
out->stage_classifier = (CvHidHaarStageClassifier*)(out + 1);
haar_classifier_ptr = (CvHidHaarClassifier*)(out->stage_classifier + cascade->count);
haar_node_ptr = (CvHidHaarTreeNode*)(haar_classifier_ptr + total_classifiers);
out->isStumpBased = 1;
out->has_tilted_features = has_tilted_features;
out->is_tree = 0;
/* initialize internal representation */
for( i = 0; i < cascade->count; i++ )
{
CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i;
CvHidHaarStageClassifier* hid_stage_classifier = out->stage_classifier + i;
hid_stage_classifier->count = stage_classifier->count;
hid_stage_classifier->threshold = stage_classifier->threshold - icv_stage_threshold_bias;
hid_stage_classifier->classifier = haar_classifier_ptr;
hid_stage_classifier->two_rects = 1;
haar_classifier_ptr += stage_classifier->count;
hid_stage_classifier->parent = (stage_classifier->parent == -1)
? NULL : out->stage_classifier + stage_classifier->parent;
hid_stage_classifier->next = (stage_classifier->next == -1)
? NULL : out->stage_classifier + stage_classifier->next;
hid_stage_classifier->child = (stage_classifier->child == -1)
? NULL : out->stage_classifier + stage_classifier->child;
out->is_tree |= hid_stage_classifier->next != NULL;
for( j = 0; j < stage_classifier->count; j++ )
{
CvHaarClassifier* classifier = stage_classifier->classifier + j;
CvHidHaarClassifier* hid_classifier = hid_stage_classifier->classifier + j;
int node_count = classifier->count;
float* alpha_ptr = (float*)(haar_node_ptr + node_count);
hid_classifier->count = node_count;
hid_classifier->node = haar_node_ptr;
hid_classifier->alpha = alpha_ptr;
for( l = 0; l < node_count; l++ )
{
CvHidHaarTreeNode* node = hid_classifier->node + l;
CvHaarFeature* feature = classifier->haar_feature + l;
memset( node, -1, sizeof(*node) );
node->threshold = classifier->threshold[l];
node->left = classifier->left[l];
node->right = classifier->right[l];
if( fabs(feature->rect[2].weight) < DBL_EPSILON ||
feature->rect[2].r.width == 0 ||
feature->rect[2].r.height == 0 )
memset( &(node->feature.rect[2]), 0, sizeof(node->feature.rect[2]) );
else
hid_stage_classifier->two_rects = 0;
}
memcpy( alpha_ptr, classifier->alpha, (node_count+1)*sizeof(alpha_ptr[0]));
haar_node_ptr =
(CvHidHaarTreeNode*)cvAlignPtr(alpha_ptr+node_count+1, sizeof(void*));
out->isStumpBased &= node_count == 1;
}
}
/*
#ifdef HAVE_IPP
int can_use_ipp = !out->has_tilted_features && !out->is_tree && out->isStumpBased;
if( can_use_ipp )
{
int ipp_datasize = cascade->count*sizeof(out->ipp_stages[0]);
float ipp_weight_scale=(float)(1./((orig_window_size.width-icv_object_win_border*2)*
(orig_window_size.height-icv_object_win_border*2)));
out->ipp_stages = (void**)cvAlloc( ipp_datasize );
memset( out->ipp_stages, 0, ipp_datasize );
ipp_features = (CvRect*)cvAlloc( max_count*3*sizeof(ipp_features[0]) );
ipp_weights = (float*)cvAlloc( max_count*3*sizeof(ipp_weights[0]) );
ipp_thresholds = (float*)cvAlloc( max_count*sizeof(ipp_thresholds[0]) );
ipp_val1 = (float*)cvAlloc( max_count*sizeof(ipp_val1[0]) );
ipp_val2 = (float*)cvAlloc( max_count*sizeof(ipp_val2[0]) );
ipp_counts = (int*)cvAlloc( max_count*sizeof(ipp_counts[0]) );
for( i = 0; i < cascade->count; i++ )
{
CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i;
for( j = 0, k = 0; j < stage_classifier->count; j++ )
{
CvHaarClassifier* classifier = stage_classifier->classifier + j;
int rect_count = 2 + (classifier->haar_feature->rect[2].r.width != 0);
ipp_thresholds[j] = classifier->threshold[0];
ipp_val1[j] = classifier->alpha[0];
ipp_val2[j] = classifier->alpha[1];
ipp_counts[j] = rect_count;
for( l = 0; l < rect_count; l++, k++ )
{
ipp_features[k] = classifier->haar_feature->rect[l].r;
//ipp_features[k].y = orig_window_size.height - ipp_features[k].y - ipp_features[k].height;
ipp_weights[k] = classifier->haar_feature->rect[l].weight*ipp_weight_scale;
}
}
if( ippiHaarClassifierInitAlloc_32f( (IppiHaarClassifier_32f**)&out->ipp_stages[i],
(const IppiRect*)ipp_features, ipp_weights, ipp_thresholds,
ipp_val1, ipp_val2, ipp_counts, stage_classifier->count ) < 0 )
break;
}
if( i < cascade->count )
{
for( j = 0; j < i; j++ )
if( out->ipp_stages[i] )
ippiHaarClassifierFree_32f( (IppiHaarClassifier_32f*)out->ipp_stages[i] );
cvFree( &out->ipp_stages );
}
}
#endif
*/
cascade->hid_cascade = out;
assert( (char*)haar_node_ptr - (char*)out <= datasize );
cvFree( &ipp_features );
cvFree( &ipp_weights );
cvFree( &ipp_thresholds );
cvFree( &ipp_val1 );
cvFree( &ipp_val2 );
cvFree( &ipp_counts );
return out;
}
#define sum_elem_ptr(sum,row,col) \
((sumtype*)CV_MAT_ELEM_PTR_FAST((sum),(row),(col),sizeof(sumtype)))
#define sqsum_elem_ptr(sqsum,row,col) \
((sqsumtype*)CV_MAT_ELEM_PTR_FAST((sqsum),(row),(col),sizeof(sqsumtype)))
#define calc_sum(rect,offset) \
((rect).p0[offset] - (rect).p1[offset] - (rect).p2[offset] + (rect).p3[offset])
#define calc_sumf(rect,offset) \
static_cast<float>((rect).p0[offset] - (rect).p1[offset] - (rect).p2[offset] + (rect).p3[offset])
CV_IMPL void
cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* _cascade,
const CvArr* _sum,
const CvArr* _sqsum,
const CvArr* _tilted_sum,
double scale )
{
CvMat sum_stub, *sum = (CvMat*)_sum;
CvMat sqsum_stub, *sqsum = (CvMat*)_sqsum;
CvMat tilted_stub, *tilted = (CvMat*)_tilted_sum;
CvHidHaarClassifierCascade* cascade;
int coi0 = 0, coi1 = 0;
int i;
CvRect equRect;
double weight_scale;
if( !CV_IS_HAAR_CLASSIFIER(_cascade) )
CV_Error( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" );
if( scale <= 0 )
CV_Error( CV_StsOutOfRange, "Scale must be positive" );
sum = cvGetMat( sum, &sum_stub, &coi0 );
sqsum = cvGetMat( sqsum, &sqsum_stub, &coi1 );
if( coi0 || coi1 )
CV_Error( CV_BadCOI, "COI is not supported" );
if( !CV_ARE_SIZES_EQ( sum, sqsum ))
CV_Error( CV_StsUnmatchedSizes, "All integral images must have the same size" );
if( CV_MAT_TYPE(sqsum->type) != CV_64FC1 ||
CV_MAT_TYPE(sum->type) != CV_32SC1 )
CV_Error( CV_StsUnsupportedFormat,
"Only (32s, 64f, 32s) combination of (sum,sqsum,tilted_sum) formats is allowed" );
if( !_cascade->hid_cascade )
icvCreateHidHaarClassifierCascade(_cascade);
cascade = _cascade->hid_cascade;
if( cascade->has_tilted_features )
{
tilted = cvGetMat( tilted, &tilted_stub, &coi1 );
if( CV_MAT_TYPE(tilted->type) != CV_32SC1 )
CV_Error( CV_StsUnsupportedFormat,
"Only (32s, 64f, 32s) combination of (sum,sqsum,tilted_sum) formats is allowed" );
if( sum->step != tilted->step )
CV_Error( CV_StsUnmatchedSizes,
"Sum and tilted_sum must have the same stride (step, widthStep)" );
if( !CV_ARE_SIZES_EQ( sum, tilted ))
CV_Error( CV_StsUnmatchedSizes, "All integral images must have the same size" );
cascade->tilted = *tilted;
}
_cascade->scale = scale;
_cascade->real_window_size.width = cvRound( _cascade->orig_window_size.width * scale );
_cascade->real_window_size.height = cvRound( _cascade->orig_window_size.height * scale );
cascade->sum = *sum;
cascade->sqsum = *sqsum;
equRect.x = equRect.y = cvRound(scale);
equRect.width = cvRound((_cascade->orig_window_size.width-2)*scale);
equRect.height = cvRound((_cascade->orig_window_size.height-2)*scale);
weight_scale = 1./(equRect.width*equRect.height);
cascade->inv_window_area = weight_scale;
cascade->p0 = sum_elem_ptr(*sum, equRect.y, equRect.x);
cascade->p1 = sum_elem_ptr(*sum, equRect.y, equRect.x + equRect.width );
cascade->p2 = sum_elem_ptr(*sum, equRect.y + equRect.height, equRect.x );
cascade->p3 = sum_elem_ptr(*sum, equRect.y + equRect.height,
equRect.x + equRect.width );
cascade->pq0 = sqsum_elem_ptr(*sqsum, equRect.y, equRect.x);
cascade->pq1 = sqsum_elem_ptr(*sqsum, equRect.y, equRect.x + equRect.width );
cascade->pq2 = sqsum_elem_ptr(*sqsum, equRect.y + equRect.height, equRect.x );
cascade->pq3 = sqsum_elem_ptr(*sqsum, equRect.y + equRect.height,
equRect.x + equRect.width );
/* init pointers in haar features according to real window size and
given image pointers */
for( i = 0; i < _cascade->count; i++ )
{
int j, k, l;
for( j = 0; j < cascade->stage_classifier[i].count; j++ )
{
for( l = 0; l < cascade->stage_classifier[i].classifier[j].count; l++ )
{
CvHaarFeature* feature =
&_cascade->stage_classifier[i].classifier[j].haar_feature[l];
/* CvHidHaarClassifier* classifier =
cascade->stage_classifier[i].classifier + j; */
CvHidHaarFeature* hidfeature =
&cascade->stage_classifier[i].classifier[j].node[l].feature;
double sum0 = 0, area0 = 0;
CvRect r[3];
int base_w = -1, base_h = -1;
int new_base_w = 0, new_base_h = 0;
int kx, ky;
int flagx = 0, flagy = 0;
int x0 = 0, y0 = 0;
int nr;
/* align blocks */
for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ )
{
if( !hidfeature->rect[k].p0 )
break;
r[k] = feature->rect[k].r;
base_w = (int)CV_IMIN( (unsigned)base_w, (unsigned)(r[k].width-1) );
base_w = (int)CV_IMIN( (unsigned)base_w, (unsigned)(r[k].x - r[0].x-1) );
base_h = (int)CV_IMIN( (unsigned)base_h, (unsigned)(r[k].height-1) );
base_h = (int)CV_IMIN( (unsigned)base_h, (unsigned)(r[k].y - r[0].y-1) );
}
nr = k;
base_w += 1;
base_h += 1;
kx = r[0].width / base_w;
ky = r[0].height / base_h;
if( kx <= 0 )
{
flagx = 1;
new_base_w = cvRound( r[0].width * scale ) / kx;
x0 = cvRound( r[0].x * scale );
}
if( ky <= 0 )
{
flagy = 1;
new_base_h = cvRound( r[0].height * scale ) / ky;
y0 = cvRound( r[0].y * scale );
}
for( k = 0; k < nr; k++ )
{
CvRect tr;
double correction_ratio;
if( flagx )
{
tr.x = (r[k].x - r[0].x) * new_base_w / base_w + x0;
tr.width = r[k].width * new_base_w / base_w;
}
else
{
tr.x = cvRound( r[k].x * scale );
tr.width = cvRound( r[k].width * scale );
}
if( flagy )
{
tr.y = (r[k].y - r[0].y) * new_base_h / base_h + y0;
tr.height = r[k].height * new_base_h / base_h;
}
else
{
tr.y = cvRound( r[k].y * scale );
tr.height = cvRound( r[k].height * scale );
}
#if CV_ADJUST_WEIGHTS
{
// RAINER START
const float orig_feature_size = (float)(feature->rect[k].r.width)*feature->rect[k].r.height;
const float orig_norm_size = (float)(_cascade->orig_window_size.width)*(_cascade->orig_window_size.height);
const float feature_size = float(tr.width*tr.height);
//const float normSize = float(equRect.width*equRect.height);
float target_ratio = orig_feature_size / orig_norm_size;
//float isRatio = featureSize / normSize;
//correctionRatio = targetRatio / isRatio / normSize;
correction_ratio = target_ratio / feature_size;
// RAINER END
}
#else
correction_ratio = weight_scale * (!feature->tilted ? 1 : 0.5);
#endif
if( !feature->tilted )
{
hidfeature->rect[k].p0 = sum_elem_ptr(*sum, tr.y, tr.x);
hidfeature->rect[k].p1 = sum_elem_ptr(*sum, tr.y, tr.x + tr.width);
hidfeature->rect[k].p2 = sum_elem_ptr(*sum, tr.y + tr.height, tr.x);
hidfeature->rect[k].p3 = sum_elem_ptr(*sum, tr.y + tr.height, tr.x + tr.width);
}
else
{
hidfeature->rect[k].p2 = sum_elem_ptr(*tilted, tr.y + tr.width, tr.x + tr.width);
hidfeature->rect[k].p3 = sum_elem_ptr(*tilted, tr.y + tr.width + tr.height,
tr.x + tr.width - tr.height);
hidfeature->rect[k].p0 = sum_elem_ptr(*tilted, tr.y, tr.x);
hidfeature->rect[k].p1 = sum_elem_ptr(*tilted, tr.y + tr.height, tr.x - tr.height);
}
hidfeature->rect[k].weight = (float)(feature->rect[k].weight * correction_ratio);
if( k == 0 )
area0 = tr.width * tr.height;
else
sum0 += hidfeature->rect[k].weight * tr.width * tr.height;
}
hidfeature->rect[0].weight = (float)(-sum0/area0);
} /* l */
} /* j */
}
}
// AVX version icvEvalHidHaarClassifier. Process 8 CvHidHaarClassifiers per call. Check AVX support before invocation!!
#ifdef CV_HAAR_USE_AVX
CV_INLINE
double icvEvalHidHaarClassifierAVX( CvHidHaarClassifier* classifier,
double variance_norm_factor, size_t p_offset )
{
int CV_DECL_ALIGNED(32) idxV[8] = {0,0,0,0,0,0,0,0};
uchar flags[8] = {0,0,0,0,0,0,0,0};
CvHidHaarTreeNode* nodes[8];
double res = 0;
uchar exitConditionFlag = 0;
for(;;)
{
float CV_DECL_ALIGNED(32) tmp[8] = {0,0,0,0,0,0,0,0};
nodes[0] = (classifier+0)->node + idxV[0];
nodes[1] = (classifier+1)->node + idxV[1];
nodes[2] = (classifier+2)->node + idxV[2];
nodes[3] = (classifier+3)->node + idxV[3];
nodes[4] = (classifier+4)->node + idxV[4];
nodes[5] = (classifier+5)->node + idxV[5];
nodes[6] = (classifier+6)->node + idxV[6];
nodes[7] = (classifier+7)->node + idxV[7];
__m256 t = _mm256_set1_ps(static_cast<float>(variance_norm_factor));
t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,
nodes[6]->threshold,
nodes[5]->threshold,
nodes[4]->threshold,
nodes[3]->threshold,
nodes[2]->threshold,
nodes[1]->threshold,
nodes[0]->threshold));
__m256 offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[0], p_offset),
calc_sumf(nodes[6]->feature.rect[0], p_offset),
calc_sumf(nodes[5]->feature.rect[0], p_offset),
calc_sumf(nodes[4]->feature.rect[0], p_offset),
calc_sumf(nodes[3]->feature.rect[0], p_offset),
calc_sumf(nodes[2]->feature.rect[0], p_offset),
calc_sumf(nodes[1]->feature.rect[0], p_offset),
calc_sumf(nodes[0]->feature.rect[0], p_offset));
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight,
nodes[6]->feature.rect[0].weight,
nodes[5]->feature.rect[0].weight,
nodes[4]->feature.rect[0].weight,
nodes[3]->feature.rect[0].weight,
nodes[2]->feature.rect[0].weight,
nodes[1]->feature.rect[0].weight,
nodes[0]->feature.rect[0].weight);
__m256 sum = _mm256_mul_ps(offset, weight);
offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[1], p_offset),
calc_sumf(nodes[6]->feature.rect[1], p_offset),
calc_sumf(nodes[5]->feature.rect[1], p_offset),
calc_sumf(nodes[4]->feature.rect[1], p_offset),
calc_sumf(nodes[3]->feature.rect[1], p_offset),
calc_sumf(nodes[2]->feature.rect[1], p_offset),
calc_sumf(nodes[1]->feature.rect[1], p_offset),
calc_sumf(nodes[0]->feature.rect[1], p_offset));
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight,
nodes[6]->feature.rect[1].weight,
nodes[5]->feature.rect[1].weight,
nodes[4]->feature.rect[1].weight,
nodes[3]->feature.rect[1].weight,
nodes[2]->feature.rect[1].weight,
nodes[1]->feature.rect[1].weight,
nodes[0]->feature.rect[1].weight);
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset, weight));
if( nodes[0]->feature.rect[2].p0 )
tmp[0] = calc_sumf(nodes[0]->feature.rect[2], p_offset) * nodes[0]->feature.rect[2].weight;
if( nodes[1]->feature.rect[2].p0 )
tmp[1] = calc_sumf(nodes[1]->feature.rect[2], p_offset) * nodes[1]->feature.rect[2].weight;
if( nodes[2]->feature.rect[2].p0 )
tmp[2] = calc_sumf(nodes[2]->feature.rect[2], p_offset) * nodes[2]->feature.rect[2].weight;
if( nodes[3]->feature.rect[2].p0 )
tmp[3] = calc_sumf(nodes[3]->feature.rect[2], p_offset) * nodes[3]->feature.rect[2].weight;
if( nodes[4]->feature.rect[2].p0 )
tmp[4] = calc_sumf(nodes[4]->feature.rect[2], p_offset) * nodes[4]->feature.rect[2].weight;
if( nodes[5]->feature.rect[2].p0 )
tmp[5] = calc_sumf(nodes[5]->feature.rect[2], p_offset) * nodes[5]->feature.rect[2].weight;
if( nodes[6]->feature.rect[2].p0 )
tmp[6] = calc_sumf(nodes[6]->feature.rect[2], p_offset) * nodes[6]->feature.rect[2].weight;
if( nodes[7]->feature.rect[2].p0 )
tmp[7] = calc_sumf(nodes[7]->feature.rect[2], p_offset) * nodes[7]->feature.rect[2].weight;
sum = _mm256_add_ps(sum,_mm256_load_ps(tmp));
__m256 left = _mm256_set_ps(static_cast<float>(nodes[7]->left), static_cast<float>(nodes[6]->left),
static_cast<float>(nodes[5]->left), static_cast<float>(nodes[4]->left),
static_cast<float>(nodes[3]->left), static_cast<float>(nodes[2]->left),
static_cast<float>(nodes[1]->left), static_cast<float>(nodes[0]->left));
__m256 right = _mm256_set_ps(static_cast<float>(nodes[7]->right),static_cast<float>(nodes[6]->right),
static_cast<float>(nodes[5]->right),static_cast<float>(nodes[4]->right),
static_cast<float>(nodes[3]->right),static_cast<float>(nodes[2]->right),
static_cast<float>(nodes[1]->right),static_cast<float>(nodes[0]->right));
_mm256_store_si256((__m256i*)idxV, _mm256_cvttps_epi32(_mm256_blendv_ps(right, left, _mm256_cmp_ps(sum, t, _CMP_LT_OQ))));
for(int i = 0; i < 8; i++)
{
if(idxV[i]<=0)
{
if(!flags[i])
{
exitConditionFlag++;
flags[i] = 1;
res += (classifier+i)->alpha[-idxV[i]];
}
idxV[i]=0;
}
}
if(exitConditionFlag == 8)
return res;
}
}
#endif //CV_HAAR_USE_AVX
CV_INLINE
double icvEvalHidHaarClassifier( CvHidHaarClassifier* classifier,
double variance_norm_factor,
size_t p_offset )
{
int idx = 0;
/*#if CV_HAAR_USE_SSE && !CV_HAAR_USE_AVX
if(cv::checkHardwareSupport(CV_CPU_SSE2))//based on old SSE variant. Works slow
{
double CV_DECL_ALIGNED(16) temp[2];
__m128d zero = _mm_setzero_pd();
do
{
CvHidHaarTreeNode* node = classifier->node + idx;
__m128d t = _mm_set1_pd((node->threshold)*variance_norm_factor);
__m128d left = _mm_set1_pd(node->left);
__m128d right = _mm_set1_pd(node->right);
double _sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
_sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
if( node->feature.rect[2].p0 )
_sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
__m128d sum = _mm_set1_pd(_sum);
t = _mm_cmplt_sd(sum, t);
sum = _mm_blendv_pd(right, left, t);
_mm_store_pd(temp, sum);
idx = (int)temp[0];
}
while(idx > 0 );
}
else
#endif*/
{
do
{
CvHidHaarTreeNode* node = classifier->node + idx;
double t = node->threshold * variance_norm_factor;
double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
if( node->feature.rect[2].p0 )
sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
idx = sum < t ? node->left : node->right;
}
while( idx > 0 );
}
return classifier->alpha[-idx];
}
static int
cvRunHaarClassifierCascadeSum( const CvHaarClassifierCascade* _cascade,
CvPoint pt, double& stage_sum, int start_stage )
{
#ifdef CV_HAAR_USE_AVX
bool haveAVX = false;
if(cv::checkHardwareSupport(CV_CPU_AVX))
if(__xgetbv()&0x6)// Check if the OS will save the YMM registers
haveAVX = true;
#else
# ifdef CV_HAAR_USE_SSE
bool haveSSE2 = cv::checkHardwareSupport(CV_CPU_SSE2);
# endif
#endif
int p_offset, pq_offset;
int i, j;
double mean, variance_norm_factor;
CvHidHaarClassifierCascade* cascade;
if( !CV_IS_HAAR_CLASSIFIER(_cascade) )
CV_Error( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid cascade pointer" );
cascade = _cascade->hid_cascade;
if( !cascade )
CV_Error( CV_StsNullPtr, "Hidden cascade has not been created.\n"
"Use cvSetImagesForHaarClassifierCascade" );
if( pt.x < 0 || pt.y < 0 ||
pt.x + _cascade->real_window_size.width >= cascade->sum.width ||
pt.y + _cascade->real_window_size.height >= cascade->sum.height )
return -1;
p_offset = pt.y * (cascade->sum.step/sizeof(sumtype)) + pt.x;
pq_offset = pt.y * (cascade->sqsum.step/sizeof(sqsumtype)) + pt.x;
mean = calc_sum(*cascade,p_offset)*cascade->inv_window_area;
variance_norm_factor = cascade->pq0[pq_offset] - cascade->pq1[pq_offset] -
cascade->pq2[pq_offset] + cascade->pq3[pq_offset];
variance_norm_factor = variance_norm_factor*cascade->inv_window_area - mean*mean;
if( variance_norm_factor >= 0. )
variance_norm_factor = std::sqrt(variance_norm_factor);
else
variance_norm_factor = 1.;
if( cascade->is_tree )
{
CvHidHaarStageClassifier* ptr = cascade->stage_classifier;
assert( start_stage == 0 );
while( ptr )
{
stage_sum = 0.0;
j = 0;
#ifdef CV_HAAR_USE_AVX
if(haveAVX)
{
for( ; j <= ptr->count - 8; j += 8 )
{
stage_sum += icvEvalHidHaarClassifierAVX(
ptr->classifier + j,
variance_norm_factor, p_offset );
}
}
#endif
for( ; j < ptr->count; j++ )
{
stage_sum += icvEvalHidHaarClassifier( ptr->classifier + j, variance_norm_factor, p_offset );
}
if( stage_sum >= ptr->threshold )
{
ptr = ptr->child;
}
else
{
while( ptr && ptr->next == NULL ) ptr = ptr->parent;
if( ptr == NULL )
return 0;
ptr = ptr->next;
}
}
}
else if( cascade->isStumpBased )
{
#ifdef CV_HAAR_USE_AVX
if(haveAVX)
{
CvHidHaarClassifier* classifiers[8];
CvHidHaarTreeNode* nodes[8];
for( i = start_stage; i < cascade->count; i++ )
{
stage_sum = 0.0;
j = 0;
float CV_DECL_ALIGNED(32) buf[8];
if( cascade->stage_classifier[i].two_rects )
{
for( ; j <= cascade->stage_classifier[i].count - 8; j += 8 )
{
classifiers[0] = cascade->stage_classifier[i].classifier + j;
nodes[0] = classifiers[0]->node;
classifiers[1] = cascade->stage_classifier[i].classifier + j + 1;
nodes[1] = classifiers[1]->node;
classifiers[2] = cascade->stage_classifier[i].classifier + j + 2;
nodes[2] = classifiers[2]->node;
classifiers[3] = cascade->stage_classifier[i].classifier + j + 3;
nodes[3] = classifiers[3]->node;
classifiers[4] = cascade->stage_classifier[i].classifier + j + 4;
nodes[4] = classifiers[4]->node;
classifiers[5] = cascade->stage_classifier[i].classifier + j + 5;
nodes[5] = classifiers[5]->node;
classifiers[6] = cascade->stage_classifier[i].classifier + j + 6;
nodes[6] = classifiers[6]->node;
classifiers[7] = cascade->stage_classifier[i].classifier + j + 7;
nodes[7] = classifiers[7]->node;
__m256 t = _mm256_set1_ps(static_cast<float>(variance_norm_factor));
t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,
nodes[6]->threshold,
nodes[5]->threshold,
nodes[4]->threshold,
nodes[3]->threshold,
nodes[2]->threshold,
nodes[1]->threshold,
nodes[0]->threshold));
__m256 offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[0], p_offset),
calc_sumf(nodes[6]->feature.rect[0], p_offset),
calc_sumf(nodes[5]->feature.rect[0], p_offset),
calc_sumf(nodes[4]->feature.rect[0], p_offset),
calc_sumf(nodes[3]->feature.rect[0], p_offset),
calc_sumf(nodes[2]->feature.rect[0], p_offset),
calc_sumf(nodes[1]->feature.rect[0], p_offset),
calc_sumf(nodes[0]->feature.rect[0], p_offset));
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight,
nodes[6]->feature.rect[0].weight,
nodes[5]->feature.rect[0].weight,
nodes[4]->feature.rect[0].weight,
nodes[3]->feature.rect[0].weight,
nodes[2]->feature.rect[0].weight,
nodes[1]->feature.rect[0].weight,
nodes[0]->feature.rect[0].weight);
__m256 sum = _mm256_mul_ps(offset, weight);
offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[1], p_offset),
calc_sumf(nodes[6]->feature.rect[1], p_offset),
calc_sumf(nodes[5]->feature.rect[1], p_offset),
calc_sumf(nodes[4]->feature.rect[1], p_offset),
calc_sumf(nodes[3]->feature.rect[1], p_offset),
calc_sumf(nodes[2]->feature.rect[1], p_offset),
calc_sumf(nodes[1]->feature.rect[1], p_offset),
calc_sumf(nodes[0]->feature.rect[1], p_offset));
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight,
nodes[6]->feature.rect[1].weight,
nodes[5]->feature.rect[1].weight,
nodes[4]->feature.rect[1].weight,
nodes[3]->feature.rect[1].weight,
nodes[2]->feature.rect[1].weight,
nodes[1]->feature.rect[1].weight,
nodes[0]->feature.rect[1].weight);
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset,weight));
__m256 alpha0 = _mm256_set_ps(classifiers[7]->alpha[0],
classifiers[6]->alpha[0],
classifiers[5]->alpha[0],
classifiers[4]->alpha[0],
classifiers[3]->alpha[0],
classifiers[2]->alpha[0],
classifiers[1]->alpha[0],
classifiers[0]->alpha[0]);
__m256 alpha1 = _mm256_set_ps(classifiers[7]->alpha[1],
classifiers[6]->alpha[1],
classifiers[5]->alpha[1],
classifiers[4]->alpha[1],
classifiers[3]->alpha[1],
classifiers[2]->alpha[1],
classifiers[1]->alpha[1],
classifiers[0]->alpha[1]);
_mm256_store_ps(buf, _mm256_blendv_ps(alpha0, alpha1, _mm256_cmp_ps(t, sum, _CMP_LE_OQ)));
stage_sum += (buf[0]+buf[1]+buf[2]+buf[3]+buf[4]+buf[5]+buf[6]+buf[7]);
}
for( ; j < cascade->stage_classifier[i].count; j++ )
{
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
CvHidHaarTreeNode* node = classifier->node;
double t = node->threshold*variance_norm_factor;
double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
stage_sum += classifier->alpha[sum >= t];
}
}
else
{
for( ; j <= (cascade->stage_classifier[i].count)-8; j+=8 )
{
float CV_DECL_ALIGNED(32) tmp[8] = {0,0,0,0,0,0,0,0};
classifiers[0] = cascade->stage_classifier[i].classifier + j;
nodes[0] = classifiers[0]->node;
classifiers[1] = cascade->stage_classifier[i].classifier + j + 1;
nodes[1] = classifiers[1]->node;
classifiers[2] = cascade->stage_classifier[i].classifier + j + 2;
nodes[2] = classifiers[2]->node;
classifiers[3] = cascade->stage_classifier[i].classifier + j + 3;
nodes[3] = classifiers[3]->node;
classifiers[4] = cascade->stage_classifier[i].classifier + j + 4;
nodes[4] = classifiers[4]->node;
classifiers[5] = cascade->stage_classifier[i].classifier + j + 5;
nodes[5] = classifiers[5]->node;
classifiers[6] = cascade->stage_classifier[i].classifier + j + 6;
nodes[6] = classifiers[6]->node;
classifiers[7] = cascade->stage_classifier[i].classifier + j + 7;
nodes[7] = classifiers[7]->node;
__m256 t = _mm256_set1_ps(static_cast<float>(variance_norm_factor));
t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,
nodes[6]->threshold,
nodes[5]->threshold,
nodes[4]->threshold,
nodes[3]->threshold,
nodes[2]->threshold,
nodes[1]->threshold,
nodes[0]->threshold));
__m256 offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[0], p_offset),
calc_sumf(nodes[6]->feature.rect[0], p_offset),
calc_sumf(nodes[5]->feature.rect[0], p_offset),
calc_sumf(nodes[4]->feature.rect[0], p_offset),
calc_sumf(nodes[3]->feature.rect[0], p_offset),
calc_sumf(nodes[2]->feature.rect[0], p_offset),
calc_sumf(nodes[1]->feature.rect[0], p_offset),
calc_sumf(nodes[0]->feature.rect[0], p_offset));
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight,
nodes[6]->feature.rect[0].weight,
nodes[5]->feature.rect[0].weight,
nodes[4]->feature.rect[0].weight,
nodes[3]->feature.rect[0].weight,
nodes[2]->feature.rect[0].weight,
nodes[1]->feature.rect[0].weight,
nodes[0]->feature.rect[0].weight);
__m256 sum = _mm256_mul_ps(offset, weight);
offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[1], p_offset),
calc_sumf(nodes[6]->feature.rect[1], p_offset),
calc_sumf(nodes[5]->feature.rect[1], p_offset),
calc_sumf(nodes[4]->feature.rect[1], p_offset),
calc_sumf(nodes[3]->feature.rect[1], p_offset),
calc_sumf(nodes[2]->feature.rect[1], p_offset),
calc_sumf(nodes[1]->feature.rect[1], p_offset),
calc_sumf(nodes[0]->feature.rect[1], p_offset));
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight,
nodes[6]->feature.rect[1].weight,
nodes[5]->feature.rect[1].weight,
nodes[4]->feature.rect[1].weight,
nodes[3]->feature.rect[1].weight,
nodes[2]->feature.rect[1].weight,
nodes[1]->feature.rect[1].weight,
nodes[0]->feature.rect[1].weight);
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset, weight));
if( nodes[0]->feature.rect[2].p0 )
tmp[0] = calc_sumf(nodes[0]->feature.rect[2],p_offset) * nodes[0]->feature.rect[2].weight;
if( nodes[1]->feature.rect[2].p0 )
tmp[1] = calc_sumf(nodes[1]->feature.rect[2],p_offset) * nodes[1]->feature.rect[2].weight;
if( nodes[2]->feature.rect[2].p0 )
tmp[2] = calc_sumf(nodes[2]->feature.rect[2],p_offset) * nodes[2]->feature.rect[2].weight;
if( nodes[3]->feature.rect[2].p0 )
tmp[3] = calc_sumf(nodes[3]->feature.rect[2],p_offset) * nodes[3]->feature.rect[2].weight;
if( nodes[4]->feature.rect[2].p0 )
tmp[4] = calc_sumf(nodes[4]->feature.rect[2],p_offset) * nodes[4]->feature.rect[2].weight;
if( nodes[5]->feature.rect[2].p0 )
tmp[5] = calc_sumf(nodes[5]->feature.rect[2],p_offset) * nodes[5]->feature.rect[2].weight;
if( nodes[6]->feature.rect[2].p0 )
tmp[6] = calc_sumf(nodes[6]->feature.rect[2],p_offset) * nodes[6]->feature.rect[2].weight;
if( nodes[7]->feature.rect[2].p0 )
tmp[7] = calc_sumf(nodes[7]->feature.rect[2],p_offset) * nodes[7]->feature.rect[2].weight;
sum = _mm256_add_ps(sum, _mm256_load_ps(tmp));
__m256 alpha0 = _mm256_set_ps(classifiers[7]->alpha[0],
classifiers[6]->alpha[0],
classifiers[5]->alpha[0],
classifiers[4]->alpha[0],
classifiers[3]->alpha[0],
classifiers[2]->alpha[0],
classifiers[1]->alpha[0],
classifiers[0]->alpha[0]);
__m256 alpha1 = _mm256_set_ps(classifiers[7]->alpha[1],
classifiers[6]->alpha[1],
classifiers[5]->alpha[1],
classifiers[4]->alpha[1],
classifiers[3]->alpha[1],
classifiers[2]->alpha[1],
classifiers[1]->alpha[1],
classifiers[0]->alpha[1]);
__m256 outBuf = _mm256_blendv_ps(alpha0, alpha1, _mm256_cmp_ps(t, sum, _CMP_LE_OQ ));
outBuf = _mm256_hadd_ps(outBuf, outBuf);
outBuf = _mm256_hadd_ps(outBuf, outBuf);
_mm256_store_ps(buf, outBuf);
stage_sum += (buf[0] + buf[4]);
}
for( ; j < cascade->stage_classifier[i].count; j++ )
{
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
CvHidHaarTreeNode* node = classifier->node;
double t = node->threshold*variance_norm_factor;
double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
if( node->feature.rect[2].p0 )
sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
stage_sum += classifier->alpha[sum >= t];
}
}
if( stage_sum < cascade->stage_classifier[i].threshold )
return -i;
}
}
else
#elif defined CV_HAAR_USE_SSE //old SSE optimization
if(haveSSE2)
{
for( i = start_stage; i < cascade->count; i++ )
{
__m128d vstage_sum = _mm_setzero_pd();
if( cascade->stage_classifier[i].two_rects )
{
for( j = 0; j < cascade->stage_classifier[i].count; j++ )
{
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
CvHidHaarTreeNode* node = classifier->node;
// ayasin - NHM perf optim. Avoid use of costly flaky jcc
__m128d t = _mm_set_sd(node->threshold*variance_norm_factor);
__m128d a = _mm_set_sd(classifier->alpha[0]);
__m128d b = _mm_set_sd(classifier->alpha[1]);
__m128d sum = _mm_set_sd(calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight +
calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight);
t = _mm_cmpgt_sd(t, sum);
vstage_sum = _mm_add_sd(vstage_sum, _mm_blendv_pd(b, a, t));
}
}
else
{
for( j = 0; j < cascade->stage_classifier[i].count; j++ )
{
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
CvHidHaarTreeNode* node = classifier->node;
// ayasin - NHM perf optim. Avoid use of costly flaky jcc
__m128d t = _mm_set_sd(node->threshold*variance_norm_factor);
__m128d a = _mm_set_sd(classifier->alpha[0]);
__m128d b = _mm_set_sd(classifier->alpha[1]);
double _sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
_sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
if( node->feature.rect[2].p0 )
_sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
__m128d sum = _mm_set_sd(_sum);
t = _mm_cmpgt_sd(t, sum);
vstage_sum = _mm_add_sd(vstage_sum, _mm_blendv_pd(b, a, t));
}
}
__m128d i_threshold = _mm_set1_pd(cascade->stage_classifier[i].threshold);
if( _mm_comilt_sd(vstage_sum, i_threshold) )
return -i;
}
}
else
#endif // AVX or SSE
{
for( i = start_stage; i < cascade->count; i++ )
{
stage_sum = 0.0;
if( cascade->stage_classifier[i].two_rects )
{
for( j = 0; j < cascade->stage_classifier[i].count; j++ )
{
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
CvHidHaarTreeNode* node = classifier->node;
double t = node->threshold*variance_norm_factor;
double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
stage_sum += classifier->alpha[sum >= t];
}
}
else
{
for( j = 0; j < cascade->stage_classifier[i].count; j++ )
{
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
CvHidHaarTreeNode* node = classifier->node;
double t = node->threshold*variance_norm_factor;
double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
if( node->feature.rect[2].p0 )
sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
stage_sum += classifier->alpha[sum >= t];
}
}
if( stage_sum < cascade->stage_classifier[i].threshold )
return -i;
}
}
}
else
{
for( i = start_stage; i < cascade->count; i++ )
{
stage_sum = 0.0;
int k = 0;
#ifdef CV_HAAR_USE_AVX
if(haveAVX)
{
for( ; k < cascade->stage_classifier[i].count - 8; k += 8 )
{
stage_sum += icvEvalHidHaarClassifierAVX(
cascade->stage_classifier[i].classifier + k,
variance_norm_factor, p_offset );
}
}
#endif
for(; k < cascade->stage_classifier[i].count; k++ )
{
stage_sum += icvEvalHidHaarClassifier(
cascade->stage_classifier[i].classifier + k,
variance_norm_factor, p_offset );
}
if( stage_sum < cascade->stage_classifier[i].threshold )
return -i;
}
}
return 1;
}
CV_IMPL int
cvRunHaarClassifierCascade( const CvHaarClassifierCascade* _cascade,
CvPoint pt, int start_stage )
{
double stage_sum;
return cvRunHaarClassifierCascadeSum(_cascade, pt, stage_sum, start_stage);
}
namespace cv
{
class HaarDetectObjects_ScaleImage_Invoker : public ParallelLoopBody
{
public:
HaarDetectObjects_ScaleImage_Invoker( const CvHaarClassifierCascade* _cascade,
int _stripSize, double _factor,
const Mat& _sum1, const Mat& _sqsum1, Mat* _norm1,
Mat* _mask1, Rect _equRect, std::vector<Rect>& _vec,
std::vector<int>& _levels, std::vector<double>& _weights,
bool _outputLevels, Mutex *_mtx )
{
cascade = _cascade;
stripSize = _stripSize;
factor = _factor;
sum1 = _sum1;
sqsum1 = _sqsum1;
norm1 = _norm1;
mask1 = _mask1;
equRect = _equRect;
vec = &_vec;
rejectLevels = _outputLevels ? &_levels : 0;
levelWeights = _outputLevels ? &_weights : 0;
mtx = _mtx;
}
void operator()( const Range& range ) const
{
Size winSize0 = cascade->orig_window_size;
Size winSize(cvRound(winSize0.width*factor), cvRound(winSize0.height*factor));
int y1 = range.start*stripSize, y2 = std::min(range.end*stripSize, sum1.rows - 1 - winSize0.height);
if (y2 <= y1 || sum1.cols <= 1 + winSize0.width)
return;
Size ssz(sum1.cols - 1 - winSize0.width, y2 - y1);
int x, y, ystep = factor > 2 ? 1 : 2;
#ifdef HAVE_IPP
if( cascade->hid_cascade->ipp_stages )
{
IppiRect iequRect = {equRect.x, equRect.y, equRect.width, equRect.height};
ippiRectStdDev_32f_C1R(sum1.ptr<float>(y1), (int)sum1.step,
sqsum1.ptr<double>(y1), (int)sqsum1.step,
norm1->ptr<float>(y1), (int)norm1->step,
ippiSize(ssz.width, ssz.height), iequRect );
int positive = (ssz.width/ystep)*((ssz.height + ystep-1)/ystep);
if( ystep == 1 )
(*mask1) = Scalar::all(1);
else
for( y = y1; y < y2; y++ )
{
uchar* mask1row = mask1->ptr(y);
memset( mask1row, 0, ssz.width );
if( y % ystep == 0 )
for( x = 0; x < ssz.width; x += ystep )
mask1row[x] = (uchar)1;
}
for( int j = 0; j < cascade->count; j++ )
{
if( ippiApplyHaarClassifier_32f_C1R(
sum1.ptr<float>(y1), (int)sum1.step,
norm1->ptr<float>(y1), (int)norm1->step,
mask1->ptr<uchar>(y1), (int)mask1->step,
ippiSize(ssz.width, ssz.height), &positive,
cascade->hid_cascade->stage_classifier[j].threshold,
(IppiHaarClassifier_32f*)cascade->hid_cascade->ipp_stages[j]) < 0 )
positive = 0;
if( positive <= 0 )
break;
}
if( positive > 0 )
for( y = y1; y < y2; y += ystep )
{
uchar* mask1row = mask1->ptr(y);
for( x = 0; x < ssz.width; x += ystep )
if( mask1row[x] != 0 )
{
mtx->lock();
vec->push_back(Rect(cvRound(x*factor), cvRound(y*factor),
winSize.width, winSize.height));
mtx->unlock();
if( --positive == 0 )
break;
}
if( positive == 0 )
break;
}
}
else
#endif // IPP
for( y = y1; y < y2; y += ystep )
for( x = 0; x < ssz.width; x += ystep )
{
double gypWeight;
int result = cvRunHaarClassifierCascadeSum( cascade, cvPoint(x,y), gypWeight, 0 );
if( rejectLevels )
{
if( result == 1 )
result = -1*cascade->count;
if( cascade->count + result < 4 )
{
mtx->lock();
vec->push_back(Rect(cvRound(x*factor), cvRound(y*factor),
winSize.width, winSize.height));
rejectLevels->push_back(-result);
levelWeights->push_back(gypWeight);
mtx->unlock();
}
}
else
{
if( result > 0 )
{
mtx->lock();
vec->push_back(Rect(cvRound(x*factor), cvRound(y*factor),
winSize.width, winSize.height));
mtx->unlock();
}
}
}
}
const CvHaarClassifierCascade* cascade;
int stripSize;
double factor;
Mat sum1, sqsum1, *norm1, *mask1;
Rect equRect;
std::vector<Rect>* vec;
std::vector<int>* rejectLevels;
std::vector<double>* levelWeights;
Mutex* mtx;
};
class HaarDetectObjects_ScaleCascade_Invoker : public ParallelLoopBody
{
public:
HaarDetectObjects_ScaleCascade_Invoker( const CvHaarClassifierCascade* _cascade,
Size _winsize, const Range& _xrange, double _ystep,
size_t _sumstep, const int** _p, const int** _pq,
std::vector<Rect>& _vec, Mutex* _mtx )
{
cascade = _cascade;
winsize = _winsize;
xrange = _xrange;
ystep = _ystep;
sumstep = _sumstep;
p = _p; pq = _pq;
vec = &_vec;
mtx = _mtx;
}
void operator()( const Range& range ) const
{
int iy, startY = range.start, endY = range.end;
const int *p0 = p[0], *p1 = p[1], *p2 = p[2], *p3 = p[3];
const int *pq0 = pq[0], *pq1 = pq[1], *pq2 = pq[2], *pq3 = pq[3];
bool doCannyPruning = p0 != 0;
int sstep = (int)(sumstep/sizeof(p0[0]));
for( iy = startY; iy < endY; iy++ )
{
int ix, y = cvRound(iy*ystep), ixstep = 1;
for( ix = xrange.start; ix < xrange.end; ix += ixstep )
{
int x = cvRound(ix*ystep); // it should really be ystep, not ixstep
if( doCannyPruning )
{
int offset = y*sstep + x;
int s = p0[offset] - p1[offset] - p2[offset] + p3[offset];
int sq = pq0[offset] - pq1[offset] - pq2[offset] + pq3[offset];
if( s < 100 || sq < 20 )
{
ixstep = 2;
continue;
}
}
int result = cvRunHaarClassifierCascade( cascade, cvPoint(x, y), 0 );
if( result > 0 )
{
mtx->lock();
vec->push_back(Rect(x, y, winsize.width, winsize.height));
mtx->unlock();
}
ixstep = result != 0 ? 1 : 2;
}
}
}
const CvHaarClassifierCascade* cascade;
double ystep;
size_t sumstep;
Size winsize;
Range xrange;
const int** p;
const int** pq;
std::vector<Rect>* vec;
Mutex* mtx;
};
}
CvSeq*
cvHaarDetectObjectsForROC( const CvArr* _img,
CvHaarClassifierCascade* cascade, CvMemStorage* storage,
std::vector<int>& rejectLevels, std::vector<double>& levelWeights,
double scaleFactor, int minNeighbors, int flags,
CvSize minSize, CvSize maxSize, bool outputRejectLevels )
{
const double GROUP_EPS = 0.2;
CvMat stub, *img = (CvMat*)_img;
cv::Ptr<CvMat> temp, sum, tilted, sqsum, normImg, sumcanny, imgSmall;
CvSeq* result_seq = 0;
cv::Ptr<CvMemStorage> temp_storage;
std::vector<cv::Rect> allCandidates;
std::vector<cv::Rect> rectList;
std::vector<int> rweights;
double factor;
int coi;
bool doCannyPruning = (flags & CV_HAAR_DO_CANNY_PRUNING) != 0;
bool findBiggestObject = (flags & CV_HAAR_FIND_BIGGEST_OBJECT) != 0;
bool roughSearch = (flags & CV_HAAR_DO_ROUGH_SEARCH) != 0;
cv::Mutex mtx;
if( !CV_IS_HAAR_CLASSIFIER(cascade) )
CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier cascade" );
if( !storage )
CV_Error( CV_StsNullPtr, "Null storage pointer" );
img = cvGetMat( img, &stub, &coi );
if( coi )
CV_Error( CV_BadCOI, "COI is not supported" );
if( CV_MAT_DEPTH(img->type) != CV_8U )
CV_Error( CV_StsUnsupportedFormat, "Only 8-bit images are supported" );
if( scaleFactor <= 1 )
CV_Error( CV_StsOutOfRange, "scale factor must be > 1" );
if( findBiggestObject )
flags &= ~CV_HAAR_SCALE_IMAGE;
if( maxSize.height == 0 || maxSize.width == 0 )
{
maxSize.height = img->rows;
maxSize.width = img->cols;
}
temp.reset(cvCreateMat( img->rows, img->cols, CV_8UC1 ));
sum.reset(cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 ));
sqsum.reset(cvCreateMat( img->rows + 1, img->cols + 1, CV_64FC1 ));
if( !cascade->hid_cascade )
icvCreateHidHaarClassifierCascade(cascade);
if( cascade->hid_cascade->has_tilted_features )
tilted.reset(cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 ));
result_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), storage );
if( CV_MAT_CN(img->type) > 1 )
{
cvCvtColor( img, temp, CV_BGR2GRAY );
img = temp;
}
if( findBiggestObject )
flags &= ~(CV_HAAR_SCALE_IMAGE|CV_HAAR_DO_CANNY_PRUNING);
if( flags & CV_HAAR_SCALE_IMAGE )
{
CvSize winSize0 = cascade->orig_window_size;
#ifdef HAVE_IPP
int use_ipp = cascade->hid_cascade->ipp_stages != 0;
if( use_ipp )
normImg.reset(cvCreateMat( img->rows, img->cols, CV_32FC1));
#endif
imgSmall.reset(cvCreateMat( img->rows + 1, img->cols + 1, CV_8UC1 ));
for( factor = 1; ; factor *= scaleFactor )
{
CvSize winSize(cvRound(winSize0.width*factor),
cvRound(winSize0.height*factor));
CvSize sz(cvRound( img->cols/factor ), cvRound( img->rows/factor ));
CvSize sz1(sz.width - winSize0.width + 1, sz.height - winSize0.height + 1);
CvRect equRect(icv_object_win_border, icv_object_win_border,
winSize0.width - icv_object_win_border*2,
winSize0.height - icv_object_win_border*2);
CvMat img1, sum1, sqsum1, norm1, tilted1, mask1;
CvMat* _tilted = 0;
if( sz1.width <= 0 || sz1.height <= 0 )
break;
if( winSize.width > maxSize.width || winSize.height > maxSize.height )
break;
if( winSize.width < minSize.width || winSize.height < minSize.height )
continue;
img1 = cvMat( sz.height, sz.width, CV_8UC1, imgSmall->data.ptr );
sum1 = cvMat( sz.height+1, sz.width+1, CV_32SC1, sum->data.ptr );
sqsum1 = cvMat( sz.height+1, sz.width+1, CV_64FC1, sqsum->data.ptr );
if( tilted )
{
tilted1 = cvMat( sz.height+1, sz.width+1, CV_32SC1, tilted->data.ptr );
_tilted = &tilted1;
}
norm1 = cvMat( sz1.height, sz1.width, CV_32FC1, normImg ? normImg->data.ptr : 0 );
mask1 = cvMat( sz1.height, sz1.width, CV_8UC1, temp->data.ptr );
cvResize( img, &img1, CV_INTER_LINEAR );
cvIntegral( &img1, &sum1, &sqsum1, _tilted );
int ystep = factor > 2 ? 1 : 2;
const int LOCS_PER_THREAD = 1000;
int stripCount = ((sz1.width/ystep)*(sz1.height + ystep-1)/ystep + LOCS_PER_THREAD/2)/LOCS_PER_THREAD;
stripCount = std::min(std::max(stripCount, 1), 100);
#ifdef HAVE_IPP
if( use_ipp )
{
cv::Mat fsum(sum1.rows, sum1.cols, CV_32F, sum1.data.ptr, sum1.step);
cv::cvarrToMat(&sum1).convertTo(fsum, CV_32F, 1, -(1<<24));
}
else
#endif
cvSetImagesForHaarClassifierCascade( cascade, &sum1, &sqsum1, _tilted, 1. );
cv::Mat _norm1 = cv::cvarrToMat(&norm1), _mask1 = cv::cvarrToMat(&mask1);
cv::parallel_for_(cv::Range(0, stripCount),
cv::HaarDetectObjects_ScaleImage_Invoker(cascade,
(((sz1.height + stripCount - 1)/stripCount + ystep-1)/ystep)*ystep,
factor, cv::cvarrToMat(&sum1), cv::cvarrToMat(&sqsum1), &_norm1, &_mask1,
cv::Rect(equRect), allCandidates, rejectLevels, levelWeights, outputRejectLevels, &mtx));
}
}
else
{
int n_factors = 0;
cv::Rect scanROI;
cvIntegral( img, sum, sqsum, tilted );
if( doCannyPruning )
{
sumcanny.reset(cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 ));
cvCanny( img, temp, 0, 50, 3 );
cvIntegral( temp, sumcanny );
}
for( n_factors = 0, factor = 1;
factor*cascade->orig_window_size.width < img->cols - 10 &&
factor*cascade->orig_window_size.height < img->rows - 10;
n_factors++, factor *= scaleFactor )
;
if( findBiggestObject )
{
scaleFactor = 1./scaleFactor;
factor *= scaleFactor;
}
else
factor = 1;
for( ; n_factors-- > 0; factor *= scaleFactor )
{
const double ystep = std::max( 2., factor );
CvSize winSize(cvRound( cascade->orig_window_size.width * factor ),
cvRound( cascade->orig_window_size.height * factor ));
CvRect equRect;
int *p[4] = {0,0,0,0};
int *pq[4] = {0,0,0,0};
int startX = 0, startY = 0;
int endX = cvRound((img->cols - winSize.width) / ystep);
int endY = cvRound((img->rows - winSize.height) / ystep);
if( winSize.width < minSize.width || winSize.height < minSize.height )
{
if( findBiggestObject )
break;
continue;
}
if ( winSize.width > maxSize.width || winSize.height > maxSize.height )
{
if( !findBiggestObject )
break;
continue;
}
cvSetImagesForHaarClassifierCascade( cascade, sum, sqsum, tilted, factor );
cvZero( temp );
if( doCannyPruning )
{
equRect.x = cvRound(winSize.width*0.15);
equRect.y = cvRound(winSize.height*0.15);
equRect.width = cvRound(winSize.width*0.7);
equRect.height = cvRound(winSize.height*0.7);
p[0] = (int*)(sumcanny->data.ptr + equRect.y*sumcanny->step) + equRect.x;
p[1] = (int*)(sumcanny->data.ptr + equRect.y*sumcanny->step)
+ equRect.x + equRect.width;
p[2] = (int*)(sumcanny->data.ptr + (equRect.y + equRect.height)*sumcanny->step) + equRect.x;
p[3] = (int*)(sumcanny->data.ptr + (equRect.y + equRect.height)*sumcanny->step)
+ equRect.x + equRect.width;
pq[0] = (int*)(sum->data.ptr + equRect.y*sum->step) + equRect.x;
pq[1] = (int*)(sum->data.ptr + equRect.y*sum->step)
+ equRect.x + equRect.width;
pq[2] = (int*)(sum->data.ptr + (equRect.y + equRect.height)*sum->step) + equRect.x;
pq[3] = (int*)(sum->data.ptr + (equRect.y + equRect.height)*sum->step)
+ equRect.x + equRect.width;
}
if( scanROI.area() > 0 )
{
//adjust start_height and stop_height
startY = cvRound(scanROI.y / ystep);
endY = cvRound((scanROI.y + scanROI.height - winSize.height) / ystep);
startX = cvRound(scanROI.x / ystep);
endX = cvRound((scanROI.x + scanROI.width - winSize.width) / ystep);
}
cv::parallel_for_(cv::Range(startY, endY),
cv::HaarDetectObjects_ScaleCascade_Invoker(cascade, winSize, cv::Range(startX, endX),
ystep, sum->step, (const int**)p,
(const int**)pq, allCandidates, &mtx ));
if( findBiggestObject && !allCandidates.empty() && scanROI.area() == 0 )
{
rectList.resize(allCandidates.size());
std::copy(allCandidates.begin(), allCandidates.end(), rectList.begin());
groupRectangles(rectList, std::max(minNeighbors, 1), GROUP_EPS);
if( !rectList.empty() )
{
size_t i, sz = rectList.size();
cv::Rect maxRect;
for( i = 0; i < sz; i++ )
{
if( rectList[i].area() > maxRect.area() )
maxRect = rectList[i];
}
allCandidates.push_back(maxRect);
scanROI = maxRect;
int dx = cvRound(maxRect.width*GROUP_EPS);
int dy = cvRound(maxRect.height*GROUP_EPS);
scanROI.x = std::max(scanROI.x - dx, 0);
scanROI.y = std::max(scanROI.y - dy, 0);
scanROI.width = std::min(scanROI.width + dx*2, img->cols-1-scanROI.x);
scanROI.height = std::min(scanROI.height + dy*2, img->rows-1-scanROI.y);
double minScale = roughSearch ? 0.6 : 0.4;
minSize.width = cvRound(maxRect.width*minScale);
minSize.height = cvRound(maxRect.height*minScale);
}
}
}
}
rectList.resize(allCandidates.size());
if(!allCandidates.empty())
std::copy(allCandidates.begin(), allCandidates.end(), rectList.begin());
if( minNeighbors != 0 || findBiggestObject )
{
if( outputRejectLevels )
{
groupRectangles(rectList, rejectLevels, levelWeights, minNeighbors, GROUP_EPS );
}
else
{
groupRectangles(rectList, rweights, std::max(minNeighbors, 1), GROUP_EPS);
}
}
else
rweights.resize(rectList.size(),0);
if( findBiggestObject && rectList.size() )
{
CvAvgComp result_comp = {CvRect(),0};
for( size_t i = 0; i < rectList.size(); i++ )
{
cv::Rect r = rectList[i];
if( r.area() > cv::Rect(result_comp.rect).area() )
{
result_comp.rect = r;
result_comp.neighbors = rweights[i];
}
}
cvSeqPush( result_seq, &result_comp );
}
else
{
for( size_t i = 0; i < rectList.size(); i++ )
{
CvAvgComp c;
c.rect = rectList[i];
c.neighbors = !rweights.empty() ? rweights[i] : 0;
cvSeqPush( result_seq, &c );
}
}
return result_seq;
}
CV_IMPL CvSeq*
cvHaarDetectObjects( const CvArr* _img,
CvHaarClassifierCascade* cascade, CvMemStorage* storage,
double scaleFactor,
int minNeighbors, int flags, CvSize minSize, CvSize maxSize )
{
std::vector<int> fakeLevels;
std::vector<double> fakeWeights;
return cvHaarDetectObjectsForROC( _img, cascade, storage, fakeLevels, fakeWeights,
scaleFactor, minNeighbors, flags, minSize, maxSize, false );
}
static CvHaarClassifierCascade*
icvLoadCascadeCART( const char** input_cascade, int n, CvSize orig_window_size )
{
int i;
CvHaarClassifierCascade* cascade = icvCreateHaarClassifierCascade(n);
cascade->orig_window_size = orig_window_size;
for( i = 0; i < n; i++ )
{
int j, count, l;
float threshold = 0;
const char* stage = input_cascade[i];
int dl = 0;
/* tree links */
int parent = -1;
int next = -1;
sscanf( stage, "%d%n", &count, &dl );
stage += dl;
assert( count > 0 );
cascade->stage_classifier[i].count = count;
cascade->stage_classifier[i].classifier =
(CvHaarClassifier*)cvAlloc( count*sizeof(cascade->stage_classifier[i].classifier[0]));
for( j = 0; j < count; j++ )
{
CvHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
int k, rects = 0;
char str[100];
sscanf( stage, "%d%n", &classifier->count, &dl );
stage += dl;
classifier->haar_feature = (CvHaarFeature*) cvAlloc(
classifier->count * ( sizeof( *classifier->haar_feature ) +
sizeof( *classifier->threshold ) +
sizeof( *classifier->left ) +
sizeof( *classifier->right ) ) +
(classifier->count + 1) * sizeof( *classifier->alpha ) );
classifier->threshold = (float*) (classifier->haar_feature+classifier->count);
classifier->left = (int*) (classifier->threshold + classifier->count);
classifier->right = (int*) (classifier->left + classifier->count);
classifier->alpha = (float*) (classifier->right + classifier->count);
for( l = 0; l < classifier->count; l++ )
{
sscanf( stage, "%d%n", &rects, &dl );
stage += dl;
assert( rects >= 2 && rects <= CV_HAAR_FEATURE_MAX );
for( k = 0; k < rects; k++ )
{
CvRect r;
int band = 0;
sscanf( stage, "%d%d%d%d%d%f%n",
&r.x, &r.y, &r.width, &r.height, &band,
&(classifier->haar_feature[l].rect[k].weight), &dl );
stage += dl;
classifier->haar_feature[l].rect[k].r = r;
}
sscanf( stage, "%s%n", str, &dl );
stage += dl;
classifier->haar_feature[l].tilted = strncmp( str, "tilted", 6 ) == 0;
for( k = rects; k < CV_HAAR_FEATURE_MAX; k++ )
{
memset( classifier->haar_feature[l].rect + k, 0,
sizeof(classifier->haar_feature[l].rect[k]) );
}
sscanf( stage, "%f%d%d%n", &(classifier->threshold[l]),
&(classifier->left[l]),
&(classifier->right[l]), &dl );
stage += dl;
}
for( l = 0; l <= classifier->count; l++ )
{
sscanf( stage, "%f%n", &(classifier->alpha[l]), &dl );
stage += dl;
}
}
sscanf( stage, "%f%n", &threshold, &dl );
stage += dl;
cascade->stage_classifier[i].threshold = threshold;
/* load tree links */
if( sscanf( stage, "%d%d%n", &parent, &next, &dl ) != 2 )
{
parent = i - 1;
next = -1;
}
stage += dl;
cascade->stage_classifier[i].parent = parent;
cascade->stage_classifier[i].next = next;
cascade->stage_classifier[i].child = -1;
if( parent != -1 && cascade->stage_classifier[parent].child == -1 )
{
cascade->stage_classifier[parent].child = i;
}
}
return cascade;
}
#ifndef _MAX_PATH
#define _MAX_PATH 1024
#endif
CV_IMPL CvHaarClassifierCascade*
cvLoadHaarClassifierCascade( const char* directory, CvSize orig_window_size )
{
if( !directory )
CV_Error( CV_StsNullPtr, "Null path is passed" );
char name[_MAX_PATH];
int n = (int)strlen(directory)-1;
const char* slash = directory[n] == '\\' || directory[n] == '/' ? "" : "/";
int size = 0;
/* try to read the classifier from directory */
for( n = 0; ; n++ )
{
sprintf( name, "%s%s%d/AdaBoostCARTHaarClassifier.txt", directory, slash, n );
FILE* f = fopen( name, "rb" );
if( !f )
break;
fseek( f, 0, SEEK_END );
size += ftell( f ) + 1;
fclose(f);
}
if( n == 0 && slash[0] )
return (CvHaarClassifierCascade*)cvLoad( directory );
if( n == 0 )
CV_Error( CV_StsBadArg, "Invalid path" );
size += (n+1)*sizeof(char*);
const char** input_cascade = (const char**)cvAlloc( size );
if( !input_cascade )
CV_Error( CV_StsNoMem, "Could not allocate memory for input_cascade" );
char* ptr = (char*)(input_cascade + n + 1);
for( int i = 0; i < n; i++ )
{
sprintf( name, "%s/%d/AdaBoostCARTHaarClassifier.txt", directory, i );
FILE* f = fopen( name, "rb" );
if( !f )
CV_Error( CV_StsError, "" );
fseek( f, 0, SEEK_END );
size = ftell( f );
fseek( f, 0, SEEK_SET );
size_t elements_read = fread( ptr, 1, size, f );
CV_Assert(elements_read == (size_t)(size));
fclose(f);
input_cascade[i] = ptr;
ptr += size;
*ptr++ = '\0';
}
input_cascade[n] = 0;
CvHaarClassifierCascade* cascade = icvLoadCascadeCART( input_cascade, n, orig_window_size );
if( input_cascade )
cvFree( &input_cascade );
return cascade;
}
CV_IMPL void
cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** _cascade )
{
if( _cascade && *_cascade )
{
int i, j;
CvHaarClassifierCascade* cascade = *_cascade;
for( i = 0; i < cascade->count; i++ )
{
for( j = 0; j < cascade->stage_classifier[i].count; j++ )
cvFree( &cascade->stage_classifier[i].classifier[j].haar_feature );
cvFree( &cascade->stage_classifier[i].classifier );
}
icvReleaseHidHaarClassifierCascade( &cascade->hid_cascade );
cvFree( _cascade );
}
}
/****************************************************************************************\
* Persistence functions *
\****************************************************************************************/
/* field names */
#define ICV_HAAR_SIZE_NAME "size"
#define ICV_HAAR_STAGES_NAME "stages"
#define ICV_HAAR_TREES_NAME "trees"
#define ICV_HAAR_FEATURE_NAME "feature"
#define ICV_HAAR_RECTS_NAME "rects"
#define ICV_HAAR_TILTED_NAME "tilted"
#define ICV_HAAR_THRESHOLD_NAME "threshold"
#define ICV_HAAR_LEFT_NODE_NAME "left_node"
#define ICV_HAAR_LEFT_VAL_NAME "left_val"
#define ICV_HAAR_RIGHT_NODE_NAME "right_node"
#define ICV_HAAR_RIGHT_VAL_NAME "right_val"
#define ICV_HAAR_STAGE_THRESHOLD_NAME "stage_threshold"
#define ICV_HAAR_PARENT_NAME "parent"
#define ICV_HAAR_NEXT_NAME "next"
static int
icvIsHaarClassifier( const void* struct_ptr )
{
return CV_IS_HAAR_CLASSIFIER( struct_ptr );
}
static void*
icvReadHaarClassifier( CvFileStorage* fs, CvFileNode* node )
{
CvHaarClassifierCascade* cascade = NULL;
char buf[256];
CvFileNode* seq_fn = NULL; /* sequence */
CvFileNode* fn = NULL;
CvFileNode* stages_fn = NULL;
CvSeqReader stages_reader;
int n;
int i, j, k, l;
int parent, next;
stages_fn = cvGetFileNodeByName( fs, node, ICV_HAAR_STAGES_NAME );
if( !stages_fn || !CV_NODE_IS_SEQ( stages_fn->tag) )
CV_Error( CV_StsError, "Invalid stages node" );
n = stages_fn->data.seq->total;
cascade = icvCreateHaarClassifierCascade(n);
/* read size */
seq_fn = cvGetFileNodeByName( fs, node, ICV_HAAR_SIZE_NAME );
if( !seq_fn || !CV_NODE_IS_SEQ( seq_fn->tag ) || seq_fn->data.seq->total != 2 )
CV_Error( CV_StsError, "size node is not a valid sequence." );
fn = (CvFileNode*) cvGetSeqElem( seq_fn->data.seq, 0 );
if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0 )
CV_Error( CV_StsError, "Invalid size node: width must be positive integer" );
cascade->orig_window_size.width = fn->data.i;
fn = (CvFileNode*) cvGetSeqElem( seq_fn->data.seq, 1 );
if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0 )
CV_Error( CV_StsError, "Invalid size node: height must be positive integer" );
cascade->orig_window_size.height = fn->data.i;
cvStartReadSeq( stages_fn->data.seq, &stages_reader );
for( i = 0; i < n; ++i )
{
CvFileNode* stage_fn;
CvFileNode* trees_fn;
CvSeqReader trees_reader;
stage_fn = (CvFileNode*) stages_reader.ptr;
if( !CV_NODE_IS_MAP( stage_fn->tag ) )
{
sprintf( buf, "Invalid stage %d", i );
CV_Error( CV_StsError, buf );
}
trees_fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_TREES_NAME );
if( !trees_fn || !CV_NODE_IS_SEQ( trees_fn->tag )
|| trees_fn->data.seq->total <= 0 )
{
sprintf( buf, "Trees node is not a valid sequence. (stage %d)", i );
CV_Error( CV_StsError, buf );
}
cascade->stage_classifier[i].classifier =
(CvHaarClassifier*) cvAlloc( trees_fn->data.seq->total
* sizeof( cascade->stage_classifier[i].classifier[0] ) );
for( j = 0; j < trees_fn->data.seq->total; ++j )
{
cascade->stage_classifier[i].classifier[j].haar_feature = NULL;
}
cascade->stage_classifier[i].count = trees_fn->data.seq->total;
cvStartReadSeq( trees_fn->data.seq, &trees_reader );
for( j = 0; j < trees_fn->data.seq->total; ++j )
{
CvFileNode* tree_fn;
CvSeqReader tree_reader;
CvHaarClassifier* classifier;
int last_idx;
classifier = &cascade->stage_classifier[i].classifier[j];
tree_fn = (CvFileNode*) trees_reader.ptr;
if( !CV_NODE_IS_SEQ( tree_fn->tag ) || tree_fn->data.seq->total <= 0 )
{
sprintf( buf, "Tree node is not a valid sequence."
" (stage %d, tree %d)", i, j );
CV_Error( CV_StsError, buf );
}
classifier->count = tree_fn->data.seq->total;
classifier->haar_feature = (CvHaarFeature*) cvAlloc(
classifier->count * ( sizeof( *classifier->haar_feature ) +
sizeof( *classifier->threshold ) +
sizeof( *classifier->left ) +
sizeof( *classifier->right ) ) +
(classifier->count + 1) * sizeof( *classifier->alpha ) );
classifier->threshold = (float*) (classifier->haar_feature+classifier->count);
classifier->left = (int*) (classifier->threshold + classifier->count);
classifier->right = (int*) (classifier->left + classifier->count);
classifier->alpha = (float*) (classifier->right + classifier->count);
cvStartReadSeq( tree_fn->data.seq, &tree_reader );
for( k = 0, last_idx = 0; k < tree_fn->data.seq->total; ++k )
{
CvFileNode* node_fn;
CvFileNode* feature_fn;
CvFileNode* rects_fn;
CvSeqReader rects_reader;
node_fn = (CvFileNode*) tree_reader.ptr;
if( !CV_NODE_IS_MAP( node_fn->tag ) )
{
sprintf( buf, "Tree node %d is not a valid map. (stage %d, tree %d)",
k, i, j );
CV_Error( CV_StsError, buf );
}
feature_fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_FEATURE_NAME );
if( !feature_fn || !CV_NODE_IS_MAP( feature_fn->tag ) )
{
sprintf( buf, "Feature node is not a valid map. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
rects_fn = cvGetFileNodeByName( fs, feature_fn, ICV_HAAR_RECTS_NAME );
if( !rects_fn || !CV_NODE_IS_SEQ( rects_fn->tag )
|| rects_fn->data.seq->total < 1
|| rects_fn->data.seq->total > CV_HAAR_FEATURE_MAX )
{
sprintf( buf, "Rects node is not a valid sequence. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
cvStartReadSeq( rects_fn->data.seq, &rects_reader );
for( l = 0; l < rects_fn->data.seq->total; ++l )
{
CvFileNode* rect_fn;
CvRect r;
rect_fn = (CvFileNode*) rects_reader.ptr;
if( !CV_NODE_IS_SEQ( rect_fn->tag ) || rect_fn->data.seq->total != 5 )
{
sprintf( buf, "Rect %d is not a valid sequence. "
"(stage %d, tree %d, node %d)", l, i, j, k );
CV_Error( CV_StsError, buf );
}
fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 0 );
if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i < 0 )
{
sprintf( buf, "x coordinate must be non-negative integer. "
"(stage %d, tree %d, node %d, rect %d)", i, j, k, l );
CV_Error( CV_StsError, buf );
}
r.x = fn->data.i;
fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 1 );
if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i < 0 )
{
sprintf( buf, "y coordinate must be non-negative integer. "
"(stage %d, tree %d, node %d, rect %d)", i, j, k, l );
CV_Error( CV_StsError, buf );
}
r.y = fn->data.i;
fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 2 );
if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0
|| r.x + fn->data.i > cascade->orig_window_size.width )
{
sprintf( buf, "width must be positive integer and "
"(x + width) must not exceed window width. "
"(stage %d, tree %d, node %d, rect %d)", i, j, k, l );
CV_Error( CV_StsError, buf );
}
r.width = fn->data.i;
fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 3 );
if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0
|| r.y + fn->data.i > cascade->orig_window_size.height )
{
sprintf( buf, "height must be positive integer and "
"(y + height) must not exceed window height. "
"(stage %d, tree %d, node %d, rect %d)", i, j, k, l );
CV_Error( CV_StsError, buf );
}
r.height = fn->data.i;
fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 4 );
if( !CV_NODE_IS_REAL( fn->tag ) )
{
sprintf( buf, "weight must be real number. "
"(stage %d, tree %d, node %d, rect %d)", i, j, k, l );
CV_Error( CV_StsError, buf );
}
classifier->haar_feature[k].rect[l].weight = (float) fn->data.f;
classifier->haar_feature[k].rect[l].r = r;
CV_NEXT_SEQ_ELEM( sizeof( *rect_fn ), rects_reader );
} /* for each rect */
for( l = rects_fn->data.seq->total; l < CV_HAAR_FEATURE_MAX; ++l )
{
classifier->haar_feature[k].rect[l].weight = 0;
classifier->haar_feature[k].rect[l].r = cvRect( 0, 0, 0, 0 );
}
fn = cvGetFileNodeByName( fs, feature_fn, ICV_HAAR_TILTED_NAME);
if( !fn || !CV_NODE_IS_INT( fn->tag ) )
{
sprintf( buf, "tilted must be 0 or 1. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
classifier->haar_feature[k].tilted = ( fn->data.i != 0 );
fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_THRESHOLD_NAME);
if( !fn || !CV_NODE_IS_REAL( fn->tag ) )
{
sprintf( buf, "threshold must be real number. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
classifier->threshold[k] = (float) fn->data.f;
fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_LEFT_NODE_NAME);
if( fn )
{
if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= k
|| fn->data.i >= tree_fn->data.seq->total )
{
sprintf( buf, "left node must be valid node number. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
/* left node */
classifier->left[k] = fn->data.i;
}
else
{
fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_LEFT_VAL_NAME );
if( !fn )
{
sprintf( buf, "left node or left value must be specified. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
if( !CV_NODE_IS_REAL( fn->tag ) )
{
sprintf( buf, "left value must be real number. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
/* left value */
if( last_idx >= classifier->count + 1 )
{
sprintf( buf, "Tree structure is broken: too many values. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
classifier->left[k] = -last_idx;
classifier->alpha[last_idx++] = (float) fn->data.f;
}
fn = cvGetFileNodeByName( fs, node_fn,ICV_HAAR_RIGHT_NODE_NAME);
if( fn )
{
if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= k
|| fn->data.i >= tree_fn->data.seq->total )
{
sprintf( buf, "right node must be valid node number. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
/* right node */
classifier->right[k] = fn->data.i;
}
else
{
fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_RIGHT_VAL_NAME );
if( !fn )
{
sprintf( buf, "right node or right value must be specified. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
if( !CV_NODE_IS_REAL( fn->tag ) )
{
sprintf( buf, "right value must be real number. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
/* right value */
if( last_idx >= classifier->count + 1 )
{
sprintf( buf, "Tree structure is broken: too many values. "
"(stage %d, tree %d, node %d)", i, j, k );
CV_Error( CV_StsError, buf );
}
classifier->right[k] = -last_idx;
classifier->alpha[last_idx++] = (float) fn->data.f;
}
CV_NEXT_SEQ_ELEM( sizeof( *node_fn ), tree_reader );
} /* for each node */
if( last_idx != classifier->count + 1 )
{
sprintf( buf, "Tree structure is broken: too few values. "
"(stage %d, tree %d)", i, j );
CV_Error( CV_StsError, buf );
}
CV_NEXT_SEQ_ELEM( sizeof( *tree_fn ), trees_reader );
} /* for each tree */
fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_STAGE_THRESHOLD_NAME);
if( !fn || !CV_NODE_IS_REAL( fn->tag ) )
{
sprintf( buf, "stage threshold must be real number. (stage %d)", i );
CV_Error( CV_StsError, buf );
}
cascade->stage_classifier[i].threshold = (float) fn->data.f;
parent = i - 1;
next = -1;
fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_PARENT_NAME );
if( !fn || !CV_NODE_IS_INT( fn->tag )
|| fn->data.i < -1 || fn->data.i >= cascade->count )
{
sprintf( buf, "parent must be integer number. (stage %d)", i );
CV_Error( CV_StsError, buf );
}
parent = fn->data.i;
fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_NEXT_NAME );
if( !fn || !CV_NODE_IS_INT( fn->tag )
|| fn->data.i < -1 || fn->data.i >= cascade->count )
{
sprintf( buf, "next must be integer number. (stage %d)", i );
CV_Error( CV_StsError, buf );
}
next = fn->data.i;
cascade->stage_classifier[i].parent = parent;
cascade->stage_classifier[i].next = next;
cascade->stage_classifier[i].child = -1;
if( parent != -1 && cascade->stage_classifier[parent].child == -1 )
{
cascade->stage_classifier[parent].child = i;
}
CV_NEXT_SEQ_ELEM( sizeof( *stage_fn ), stages_reader );
} /* for each stage */
return cascade;
}
static void
icvWriteHaarClassifier( CvFileStorage* fs, const char* name, const void* struct_ptr,
CvAttrList attributes )
{
int i, j, k, l;
char buf[256];
const CvHaarClassifierCascade* cascade = (const CvHaarClassifierCascade*) struct_ptr;
/* TODO: parameters check */
cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_HAAR, attributes );
cvStartWriteStruct( fs, ICV_HAAR_SIZE_NAME, CV_NODE_SEQ | CV_NODE_FLOW );
cvWriteInt( fs, NULL, cascade->orig_window_size.width );
cvWriteInt( fs, NULL, cascade->orig_window_size.height );
cvEndWriteStruct( fs ); /* size */
cvStartWriteStruct( fs, ICV_HAAR_STAGES_NAME, CV_NODE_SEQ );
for( i = 0; i < cascade->count; ++i )
{
cvStartWriteStruct( fs, NULL, CV_NODE_MAP );
sprintf( buf, "stage %d", i );
cvWriteComment( fs, buf, 1 );
cvStartWriteStruct( fs, ICV_HAAR_TREES_NAME, CV_NODE_SEQ );
for( j = 0; j < cascade->stage_classifier[i].count; ++j )
{
CvHaarClassifier* tree = &cascade->stage_classifier[i].classifier[j];
cvStartWriteStruct( fs, NULL, CV_NODE_SEQ );
sprintf( buf, "tree %d", j );
cvWriteComment( fs, buf, 1 );
for( k = 0; k < tree->count; ++k )
{
CvHaarFeature* feature = &tree->haar_feature[k];
cvStartWriteStruct( fs, NULL, CV_NODE_MAP );
if( k )
{
sprintf( buf, "node %d", k );
}
else
{
sprintf( buf, "root node" );
}
cvWriteComment( fs, buf, 1 );
cvStartWriteStruct( fs, ICV_HAAR_FEATURE_NAME, CV_NODE_MAP );
cvStartWriteStruct( fs, ICV_HAAR_RECTS_NAME, CV_NODE_SEQ );
for( l = 0; l < CV_HAAR_FEATURE_MAX && feature->rect[l].r.width != 0; ++l )
{
cvStartWriteStruct( fs, NULL, CV_NODE_SEQ | CV_NODE_FLOW );
cvWriteInt( fs, NULL, feature->rect[l].r.x );
cvWriteInt( fs, NULL, feature->rect[l].r.y );
cvWriteInt( fs, NULL, feature->rect[l].r.width );
cvWriteInt( fs, NULL, feature->rect[l].r.height );
cvWriteReal( fs, NULL, feature->rect[l].weight );
cvEndWriteStruct( fs ); /* rect */
}
cvEndWriteStruct( fs ); /* rects */
cvWriteInt( fs, ICV_HAAR_TILTED_NAME, feature->tilted );
cvEndWriteStruct( fs ); /* feature */
cvWriteReal( fs, ICV_HAAR_THRESHOLD_NAME, tree->threshold[k]);
if( tree->left[k] > 0 )
{
cvWriteInt( fs, ICV_HAAR_LEFT_NODE_NAME, tree->left[k] );
}
else
{
cvWriteReal( fs, ICV_HAAR_LEFT_VAL_NAME,
tree->alpha[-tree->left[k]] );
}
if( tree->right[k] > 0 )
{
cvWriteInt( fs, ICV_HAAR_RIGHT_NODE_NAME, tree->right[k] );
}
else
{
cvWriteReal( fs, ICV_HAAR_RIGHT_VAL_NAME,
tree->alpha[-tree->right[k]] );
}
cvEndWriteStruct( fs ); /* split */
}
cvEndWriteStruct( fs ); /* tree */
}
cvEndWriteStruct( fs ); /* trees */
cvWriteReal( fs, ICV_HAAR_STAGE_THRESHOLD_NAME, cascade->stage_classifier[i].threshold);
cvWriteInt( fs, ICV_HAAR_PARENT_NAME, cascade->stage_classifier[i].parent );
cvWriteInt( fs, ICV_HAAR_NEXT_NAME, cascade->stage_classifier[i].next );
cvEndWriteStruct( fs ); /* stage */
} /* for each stage */
cvEndWriteStruct( fs ); /* stages */
cvEndWriteStruct( fs ); /* root */
}
static void*
icvCloneHaarClassifier( const void* struct_ptr )
{
CvHaarClassifierCascade* cascade = NULL;
int i, j, k, n;
const CvHaarClassifierCascade* cascade_src =
(const CvHaarClassifierCascade*) struct_ptr;
n = cascade_src->count;
cascade = icvCreateHaarClassifierCascade(n);
cascade->orig_window_size = cascade_src->orig_window_size;
for( i = 0; i < n; ++i )
{
cascade->stage_classifier[i].parent = cascade_src->stage_classifier[i].parent;
cascade->stage_classifier[i].next = cascade_src->stage_classifier[i].next;
cascade->stage_classifier[i].child = cascade_src->stage_classifier[i].child;
cascade->stage_classifier[i].threshold = cascade_src->stage_classifier[i].threshold;
cascade->stage_classifier[i].count = 0;
cascade->stage_classifier[i].classifier =
(CvHaarClassifier*) cvAlloc( cascade_src->stage_classifier[i].count
* sizeof( cascade->stage_classifier[i].classifier[0] ) );
cascade->stage_classifier[i].count = cascade_src->stage_classifier[i].count;
for( j = 0; j < cascade->stage_classifier[i].count; ++j )
cascade->stage_classifier[i].classifier[j].haar_feature = NULL;
for( j = 0; j < cascade->stage_classifier[i].count; ++j )
{
const CvHaarClassifier* classifier_src =
&cascade_src->stage_classifier[i].classifier[j];
CvHaarClassifier* classifier =
&cascade->stage_classifier[i].classifier[j];
classifier->count = classifier_src->count;
classifier->haar_feature = (CvHaarFeature*) cvAlloc(
classifier->count * ( sizeof( *classifier->haar_feature ) +
sizeof( *classifier->threshold ) +
sizeof( *classifier->left ) +
sizeof( *classifier->right ) ) +
(classifier->count + 1) * sizeof( *classifier->alpha ) );
classifier->threshold = (float*) (classifier->haar_feature+classifier->count);
classifier->left = (int*) (classifier->threshold + classifier->count);
classifier->right = (int*) (classifier->left + classifier->count);
classifier->alpha = (float*) (classifier->right + classifier->count);
for( k = 0; k < classifier->count; ++k )
{
classifier->haar_feature[k] = classifier_src->haar_feature[k];
classifier->threshold[k] = classifier_src->threshold[k];
classifier->left[k] = classifier_src->left[k];
classifier->right[k] = classifier_src->right[k];
classifier->alpha[k] = classifier_src->alpha[k];
}
classifier->alpha[classifier->count] =
classifier_src->alpha[classifier->count];
}
}
return cascade;
}
CvType haar_type( CV_TYPE_NAME_HAAR, icvIsHaarClassifier,
(CvReleaseFunc)cvReleaseHaarClassifierCascade,
icvReadHaarClassifier, icvWriteHaarClassifier,
icvCloneHaarClassifier );
/* End of file. */
| 42.655897 | 130 | 0.492832 | gunnjo |
4b2ff373b7dc945b4a733bb104221e63b5b271f9 | 720 | cpp | C++ | solver/expr/detail/driver.cpp | scalexm/sat_solver | 0235f76d0a93c4b8ff59071479c8ca139d2e162a | [
"MIT"
] | 3 | 2016-02-16T17:39:28.000Z | 2018-07-04T09:11:11.000Z | solver/expr/detail/driver.cpp | scalexm/sat_solver | 0235f76d0a93c4b8ff59071479c8ca139d2e162a | [
"MIT"
] | null | null | null | solver/expr/detail/driver.cpp | scalexm/sat_solver | 0235f76d0a93c4b8ff59071479c8ca139d2e162a | [
"MIT"
] | null | null | null | /*
* expr/detail/driver.cpp
* solver
*
* Created by Alexandre Martin on 03/02/2016.
* Copyright © 2016 scalexm. All rights reserved.
*
*/
#include "driver.hpp"
#include <sstream>
namespace expr { namespace detail {
result<generic_expr> driver::parse(const std::string & str) {
begin_scan(str);
parser p(*this);
p.parse();
return std::move(m_root);
}
/*
if an error occurs, we want to use the string part of expr_result
as a return value for parse()
*/
void driver::error(const location & l, const std::string & m) {
std::ostringstream ss;
ss << l << ": " << m;
m_root = result<generic_expr> { ss.str() };
}
} } | 24 | 73 | 0.580556 | scalexm |
4b309015431d812c6a7dbb99f4666a6aa7f4c743 | 80,934 | cpp | C++ | Engine/ac/game.cpp | SpeechCenter/ags | 624e5c96da1d70346c35c81b3bb16f1ab30658bb | [
"Artistic-2.0"
] | 1 | 2021-07-24T08:37:34.000Z | 2021-07-24T08:37:34.000Z | Engine/ac/game.cpp | SpeechCenter/ags | 624e5c96da1d70346c35c81b3bb16f1ab30658bb | [
"Artistic-2.0"
] | null | null | null | Engine/ac/game.cpp | SpeechCenter/ags | 624e5c96da1d70346c35c81b3bb16f1ab30658bb | [
"Artistic-2.0"
] | null | null | null | //=============================================================================
//
// Adventure Game Studio (AGS)
//
// Copyright (C) 1999-2011 Chris Jones and 2011-20xx others
// The full list of copyright holders can be found in the Copyright.txt
// file, which is part of this source code distribution.
//
// The AGS source code is provided under the Artistic License 2.0.
// A copy of this license can be found in the file License.txt and at
// http://www.opensource.org/licenses/artistic-license-2.0.php
//
//=============================================================================
#include "ac/common.h"
#include "ac/view.h"
#include "ac/audiochannel.h"
#include "ac/character.h"
#include "ac/charactercache.h"
#include "ac/characterextras.h"
#include "ac/dialogtopic.h"
#include "ac/draw.h"
#include "ac/dynamicsprite.h"
#include "ac/event.h"
#include "ac/game.h"
#include "ac/gamesetup.h"
#include "ac/gamesetupstruct.h"
#include "ac/gamestate.h"
#include "ac/global_audio.h"
#include "ac/global_character.h"
#include "ac/global_display.h"
#include "ac/global_game.h"
#include "ac/global_gui.h"
#include "ac/global_object.h"
#include "ac/global_translation.h"
#include "ac/gui.h"
#include "ac/hotspot.h"
#include "ac/lipsync.h"
#include "ac/mouse.h"
#include "ac/movelist.h"
#include "ac/objectcache.h"
#include "ac/overlay.h"
#include "ac/path_helper.h"
#include "ac/record.h"
#include "ac/region.h"
#include "ac/richgamemedia.h"
#include "ac/room.h"
#include "ac/roomobject.h"
#include "ac/roomstatus.h"
#include "ac/runtime_defines.h"
#include "ac/screenoverlay.h"
#include "ac/spritecache.h"
#include "ac/string.h"
#include "ac/system.h"
#include "ac/timer.h"
#include "ac/translation.h"
#include "ac/dynobj/all_dynamicclasses.h"
#include "ac/dynobj/all_scriptclasses.h"
#include "ac/dynobj/cc_audiochannel.h"
#include "ac/dynobj/cc_audioclip.h"
#include "ac/statobj/staticgame.h"
#include "debug/debug_log.h"
#include "debug/out.h"
#include "device/mousew32.h"
#include "font/fonts.h"
#include "game/savegame.h"
#include "game/savegame_internal.h"
#include "gui/animatingguibutton.h"
#include "gfx/graphicsdriver.h"
#include "gfx/gfxfilter.h"
#include "gui/guidialog.h"
#include "main/graphics_mode.h"
#include "main/main.h"
#include "media/audio/audio.h"
#include "media/audio/soundclip.h"
#include "plugin/agsplugin.h"
#include "plugin/plugin_engine.h"
#include "script/cc_error.h"
#include "script/runtimescriptvalue.h"
#include "script/script.h"
#include "script/script_runtime.h"
#include "util/alignedstream.h"
#include "util/directory.h"
#include "util/filestream.h" // TODO: needed only because plugins expect file handle
#include "util/path.h"
#include "util/string_utils.h"
using namespace AGS::Common;
using namespace AGS::Engine;
extern ScriptAudioChannel scrAudioChannel[MAX_SOUND_CHANNELS + 1];
extern int time_between_timers;
extern Bitmap *virtual_screen;
extern int cur_mode,cur_cursor;
extern SpeechLipSyncLine *splipsync;
extern int numLipLines, curLipLine, curLipLinePhoneme;
extern CharacterExtras *charextra;
extern DialogTopic *dialog;
extern int ifacepopped; // currently displayed pop-up GUI (-1 if none)
extern int mouse_on_iface; // mouse cursor is over this interface
extern int mouse_ifacebut_xoffs,mouse_ifacebut_yoffs;
extern AnimatingGUIButton animbuts[MAX_ANIMATING_BUTTONS];
extern int numAnimButs;
extern ScreenOverlay screenover[MAX_SCREEN_OVERLAYS];
extern int numscreenover;
extern int is_complete_overlay,is_text_overlay;
#if defined(IOS_VERSION) || defined(ANDROID_VERSION)
extern int psp_gfx_renderer;
#endif
extern int obj_lowest_yp, char_lowest_yp;
extern int actSpsCount;
extern Bitmap **actsps;
extern IDriverDependantBitmap* *actspsbmp;
// temporary cache of walk-behind for this actsps image
extern Bitmap **actspswb;
extern IDriverDependantBitmap* *actspswbbmp;
extern CachedActSpsData* actspswbcache;
extern Bitmap **guibg;
extern IDriverDependantBitmap **guibgbmp;
extern char transFileName[MAX_PATH];
extern color palette[256];
extern int offsetx,offsety;
extern unsigned int loopcounter;
extern Bitmap *raw_saved_screen;
extern Bitmap *dynamicallyCreatedSurfaces[MAX_DYNAMIC_SURFACES];
extern IGraphicsDriver *gfxDriver;
//=============================================================================
GameState play;
GameSetup usetup;
GameSetupStruct game;
RoomStatus troom; // used for non-saveable rooms, eg. intro
RoomObject*objs;
RoomStatus*croom=NULL;
RoomStruct thisroom;
volatile int switching_away_from_game = 0;
volatile bool switched_away = false;
volatile char want_exit = 0, abort_engine = 0;
GameDataVersion loaded_game_file_version = kGameVersion_Undefined;
int frames_per_second=40;
int displayed_room=-10,starting_room = -1;
int in_new_room=0, new_room_was = 0; // 1 in new room, 2 first time in new room, 3 loading saved game
int new_room_pos=0;
int new_room_x = SCR_NO_VALUE, new_room_y = SCR_NO_VALUE;
int new_room_loop = SCR_NO_VALUE;
// initially size 1, this will be increased by the initFile function
SpriteCache spriteset(1, game.SpriteInfos);
int proper_exit=0,our_eip=0;
std::vector<GUIMain> guis;
CCGUIObject ccDynamicGUIObject;
CCCharacter ccDynamicCharacter;
CCHotspot ccDynamicHotspot;
CCRegion ccDynamicRegion;
CCInventory ccDynamicInv;
CCGUI ccDynamicGUI;
CCObject ccDynamicObject;
CCDialog ccDynamicDialog;
CCAudioClip ccDynamicAudioClip;
CCAudioChannel ccDynamicAudio;
ScriptString myScriptStringImpl;
// TODO: IMPORTANT!!
// we cannot simply replace these arrays with vectors, or other C++ containers,
// until we implement safe management of such containers in script exports
// system. Noteably we would need an alternate to StaticArray class to track
// access to their elements.
ScriptObject scrObj[MAX_ROOM_OBJECTS];
ScriptGUI *scrGui = NULL;
ScriptHotspot scrHotspot[MAX_ROOM_HOTSPOTS];
ScriptRegion scrRegion[MAX_ROOM_REGIONS];
ScriptInvItem scrInv[MAX_INV];
ScriptDialog *scrDialog;
ViewStruct*views=NULL;
CharacterCache *charcache = NULL;
ObjectCache objcache[MAX_ROOM_OBJECTS];
MoveList *mls = NULL;
//=============================================================================
char saveGameDirectory[260] = "./";
// Custom save game parent directory
String saveGameParent;
const char* sgnametemplate = "agssave.%03d";
String saveGameSuffix;
int game_paused=0;
char pexbuf[STD_BUFFER_SIZE];
unsigned int load_new_game = 0;
int load_new_game_restore = -1;
int getloctype_index = 0, getloctype_throughgui = 0;
//=============================================================================
// Audio
//=============================================================================
void Game_StopAudio(int audioType)
{
if (((audioType < 0) || (audioType >= game.audioClipTypeCount)) && (audioType != SCR_NO_VALUE))
quitprintf("!Game.StopAudio: invalid audio type %d", audioType);
int aa;
for (aa = 0; aa < MAX_SOUND_CHANNELS; aa++)
{
if (audioType == SCR_NO_VALUE)
{
stop_or_fade_out_channel(aa);
}
else
{
ScriptAudioClip *clip = AudioChannel_GetPlayingClip(&scrAudioChannel[aa]);
if ((clip != NULL) && (clip->type == audioType))
stop_or_fade_out_channel(aa);
}
}
remove_clips_of_type_from_queue(audioType);
}
int Game_IsAudioPlaying(int audioType)
{
if (((audioType < 0) || (audioType >= game.audioClipTypeCount)) && (audioType != SCR_NO_VALUE))
quitprintf("!Game.IsAudioPlaying: invalid audio type %d", audioType);
if (play.fast_forward)
return 0;
for (int aa = 0; aa < MAX_SOUND_CHANNELS; aa++)
{
ScriptAudioClip *clip = AudioChannel_GetPlayingClip(&scrAudioChannel[aa]);
if (clip != NULL)
{
if ((clip->type == audioType) || (audioType == SCR_NO_VALUE))
{
return 1;
}
}
}
return 0;
}
void Game_SetAudioTypeSpeechVolumeDrop(int audioType, int volumeDrop)
{
if ((audioType < 0) || (audioType >= game.audioClipTypeCount))
quitprintf("!Game.SetAudioTypeVolume: invalid audio type: %d", audioType);
Debug::Printf("Game.SetAudioTypeSpeechVolumeDrop: type: %d, drop: %d", audioType, volumeDrop);
game.audioClipTypes[audioType].volume_reduction_while_speech_playing = volumeDrop;
update_volume_drop_if_voiceover();
}
void Game_SetAudioTypeVolume(int audioType, int volume, int changeType)
{
if ((volume < 0) || (volume > 100))
quitprintf("!Game.SetAudioTypeVolume: volume %d is not between 0..100", volume);
if ((audioType < 0) || (audioType >= game.audioClipTypeCount))
quitprintf("!Game.SetAudioTypeVolume: invalid audio type: %d", audioType);
int aa;
Debug::Printf("Game.SetAudioTypeVolume: type: %d, volume: %d, change: %d", audioType, volume, changeType);
if ((changeType == VOL_CHANGEEXISTING) ||
(changeType == VOL_BOTH))
{
for (aa = 0; aa < MAX_SOUND_CHANNELS; aa++)
{
ScriptAudioClip *clip = AudioChannel_GetPlayingClip(&scrAudioChannel[aa]);
if ((clip != NULL) && (clip->type == audioType))
{
channels[aa]->set_volume_percent(volume);
}
}
}
if ((changeType == VOL_SETFUTUREDEFAULT) ||
(changeType == VOL_BOTH))
{
play.default_audio_type_volumes[audioType] = volume;
// update queued clip volumes
update_queued_clips_volume(audioType, volume);
}
}
int Game_GetMODPattern() {
if (current_music_type == MUS_MOD && channels[SCHAN_MUSIC]) {
return channels[SCHAN_MUSIC]->get_pos();
}
return -1;
}
//=============================================================================
// ---
//=============================================================================
int Game_GetDialogCount()
{
return game.numdialog;
}
void set_debug_mode(bool on)
{
play.debug_mode = on ? 1 : 0;
debug_set_console(on);
}
void set_game_speed(int fps) {
frames_per_second = fps;
time_between_timers = 1000 / fps;
install_int_ex(dj_timer_handler,MSEC_TO_TIMER(time_between_timers));
}
extern int cbuttfont;
extern int acdialog_font;
extern char buffer2[60];
int oldmouse;
void setup_for_dialog() {
cbuttfont = play.normal_font;
acdialog_font = play.normal_font;
SetVirtualScreen(virtual_screen);
if (!play.mouse_cursor_hidden)
domouse(1);
oldmouse=cur_cursor; set_mouse_cursor(CURS_ARROW);
}
void restore_after_dialog() {
set_mouse_cursor(oldmouse);
if (!play.mouse_cursor_hidden)
domouse(2);
construct_virtual_screen(true);
}
String get_save_game_path(int slotNum) {
String filename;
filename.Format(sgnametemplate, slotNum);
String path = saveGameDirectory;
path.Append(filename);
path.Append(saveGameSuffix);
return path;
}
// Convert a path possibly containing path tags into acceptable save path
String MakeSaveGameDir(const char *newFolder)
{
// don't allow absolute paths
if (!is_relative_filename(newFolder))
return "";
String newSaveGameDir = FixSlashAfterToken(newFolder);
if (newSaveGameDir.CompareLeft(UserSavedgamesRootToken, UserSavedgamesRootToken.GetLength()) == 0)
{
if (saveGameParent.IsEmpty())
{
newSaveGameDir.ReplaceMid(0, UserSavedgamesRootToken.GetLength(),
PathOrCurDir(platform->GetUserSavedgamesDirectory()));
}
else
{
// If there is a custom save parent directory, then replace
// not only root token, but also first subdirectory
newSaveGameDir.ClipSection('/', 0, 1);
if (!newSaveGameDir.IsEmpty())
newSaveGameDir.PrependChar('/');
newSaveGameDir.Prepend(saveGameParent);
}
}
else
{
// Convert the path relative to installation folder into path relative to the
// safe save path with default name
if (saveGameParent.IsEmpty())
newSaveGameDir.Format("%s/%s/%s", PathOrCurDir(platform->GetUserSavedgamesDirectory()),
game.saveGameFolderName, newFolder);
else
newSaveGameDir.Format("%s/%s", saveGameParent.GetCStr(), newFolder);
// For games made in the safe-path-aware versions of AGS, report a warning
if (game.options[OPT_SAFEFILEPATHS])
{
debug_script_warn("Attempt to explicitly set savegame location relative to the game installation directory ('%s') denied;\nPath will be remapped to the user documents directory: '%s'",
newFolder, newSaveGameDir.GetCStr());
}
}
return newSaveGameDir;
}
bool SetCustomSaveParent(const String &path)
{
if (SetSaveGameDirectoryPath(path, true))
{
saveGameParent = path;
return true;
}
return false;
}
bool SetSaveGameDirectoryPath(const char *newFolder, bool explicit_path)
{
if (!newFolder || newFolder[0] == 0)
newFolder = ".";
String newSaveGameDir = explicit_path ? String(newFolder) : MakeSaveGameDir(newFolder);
if (newSaveGameDir.IsEmpty())
return false;
if (!Directory::CreateDirectory(newSaveGameDir))
return false;
newSaveGameDir.AppendChar('/');
char newFolderTempFile[260];
strcpy(newFolderTempFile, newSaveGameDir);
strcat(newFolderTempFile, "agstmp.tmp");
if (!Common::File::TestCreateFile(newFolderTempFile))
return false;
// copy the Restart Game file, if applicable
char restartGamePath[260];
sprintf(restartGamePath, "%s""agssave.%d%s", saveGameDirectory, RESTART_POINT_SAVE_GAME_NUMBER, saveGameSuffix.GetCStr());
Stream *restartGameFile = Common::File::OpenFileRead(restartGamePath);
if (restartGameFile != NULL)
{
long fileSize = restartGameFile->GetLength();
char *mbuffer = (char*)malloc(fileSize);
restartGameFile->Read(mbuffer, fileSize);
delete restartGameFile;
sprintf(restartGamePath, "%s""agssave.%d%s", newSaveGameDir.GetCStr(), RESTART_POINT_SAVE_GAME_NUMBER, saveGameSuffix.GetCStr());
restartGameFile = Common::File::CreateFile(restartGamePath);
restartGameFile->Write(mbuffer, fileSize);
delete restartGameFile;
free(mbuffer);
}
strcpy(saveGameDirectory, newSaveGameDir);
return true;
}
int Game_SetSaveGameDirectory(const char *newFolder)
{
return SetSaveGameDirectoryPath(newFolder, false) ? 1 : 0;
}
const char* Game_GetSaveSlotDescription(int slnum) {
String description;
if (read_savedgame_description(get_save_game_path(slnum), description))
{
return CreateNewScriptString(description);
}
return NULL;
}
void restore_game_dialog() {
can_run_delayed_command();
if (thisroom.Options.SaveLoadDisabled == 1) {
DisplayMessage (983);
return;
}
if (inside_script) {
curscript->queue_action(ePSARestoreGameDialog, 0, "RestoreGameDialog");
return;
}
setup_for_dialog();
int toload=loadgamedialog();
restore_after_dialog();
if (toload>=0) {
try_restore_save(toload);
}
}
void save_game_dialog() {
if (thisroom.Options.SaveLoadDisabled == 1) {
DisplayMessage (983);
return;
}
if (inside_script) {
curscript->queue_action(ePSASaveGameDialog, 0, "SaveGameDialog");
return;
}
setup_for_dialog();
int toload=savegamedialog();
restore_after_dialog();
if (toload>=0)
save_game(toload,buffer2);
}
void free_do_once_tokens()
{
for (int i = 0; i < play.num_do_once_tokens; i++)
{
free(play.do_once_tokens[i]);
}
if (play.do_once_tokens != NULL)
{
free(play.do_once_tokens);
play.do_once_tokens = NULL;
}
play.num_do_once_tokens = 0;
}
// Free all the memory associated with the game
void unload_game_file() {
int bb, ee;
for (bb = 0; bb < game.numcharacters; bb++) {
if (game.charScripts != NULL)
delete game.charScripts[bb];
}
characterScriptObjNames.clear();
free(charextra);
free(mls);
free(actsps);
free(actspsbmp);
free(actspswb);
free(actspswbbmp);
free(actspswbcache);
game.charProps.clear();
for (bb = 1; bb < game.numinvitems; bb++) {
if (game.invScripts != NULL)
delete game.invScripts[bb];
}
if (game.charScripts != NULL)
{
delete game.charScripts;
delete game.invScripts;
game.charScripts = NULL;
game.invScripts = NULL;
}
if (game.dict != NULL) {
game.dict->free_memory();
free (game.dict);
game.dict = NULL;
}
if ((gameinst != NULL) && (gameinst->pc != 0))
quit("Error: unload_game called while script still running");
//->AbortAndDestroy (gameinst);
else {
delete gameinstFork;
delete gameinst;
gameinstFork = NULL;
gameinst = NULL;
}
gamescript.reset();
if ((dialogScriptsInst != NULL) && (dialogScriptsInst->pc != 0))
quit("Error: unload_game called while dialog script still running");
else if (dialogScriptsInst != NULL)
{
delete dialogScriptsInst;
dialogScriptsInst = NULL;
}
dialogScriptsScript.reset();
for (ee = 0; ee < numScriptModules; ee++) {
delete moduleInstFork[ee];
delete moduleInst[ee];
scriptModules[ee].reset();
}
moduleInstFork.resize(0);
moduleInst.resize(0);
scriptModules.resize(0);
repExecAlways.moduleHasFunction.resize(0);
lateRepExecAlways.moduleHasFunction.resize(0);
getDialogOptionsDimensionsFunc.moduleHasFunction.resize(0);
renderDialogOptionsFunc.moduleHasFunction.resize(0);
getDialogOptionUnderCursorFunc.moduleHasFunction.resize(0);
runDialogOptionMouseClickHandlerFunc.moduleHasFunction.resize(0);
runDialogOptionKeyPressHandlerFunc.moduleHasFunction.resize(0);
runDialogOptionRepExecFunc.moduleHasFunction.resize(0);
numScriptModules = 0;
if (game.audioClipCount > 0)
{
free(game.audioClips);
game.audioClipCount = 0;
free(game.audioClipTypes);
game.audioClipTypeCount = 0;
}
game.viewNames.clear();
free (views);
views = NULL;
free (game.chars);
game.chars = NULL;
free (charcache);
charcache = NULL;
if (splipsync != NULL)
{
for (ee = 0; ee < numLipLines; ee++)
{
free(splipsync[ee].endtimeoffs);
free(splipsync[ee].frame);
}
free(splipsync);
splipsync = NULL;
numLipLines = 0;
curLipLine = -1;
}
for (ee=0;ee < MAXGLOBALMES;ee++) {
if (game.messages[ee]==NULL) continue;
free (game.messages[ee]);
game.messages[ee] = NULL;
}
for (ee = 0; ee < game.roomCount; ee++)
{
free(game.roomNames[ee]);
}
if (game.roomCount > 0)
{
free(game.roomNames);
free(game.roomNumbers);
game.roomCount = 0;
}
for (ee=0;ee<game.numdialog;ee++) {
if (dialog[ee].optionscripts!=NULL)
free (dialog[ee].optionscripts);
dialog[ee].optionscripts = NULL;
}
free (dialog);
dialog = NULL;
delete [] scrDialog;
scrDialog = NULL;
for (ee = 0; ee < game.numgui; ee++) {
free (guibg[ee]);
guibg[ee] = NULL;
}
guiScriptObjNames.clear();
free(guibg);
guis.clear();
free(scrGui);
pl_stop_plugins();
ccRemoveAllSymbols();
ccUnregisterAllObjects();
for (ee=0;ee<game.numfonts;ee++)
wfreefont(ee);
free_do_once_tokens();
free(play.gui_draw_order);
resetRoomStatuses();
}
/*
// [DEPRECATED]
const char* Game_GetGlobalStrings(int index) {
if ((index < 0) || (index >= MAXGLOBALSTRINGS))
quit("!Game.GlobalStrings: invalid index");
return CreateNewScriptString(play.globalstrings[index]);
}
*/
char gamefilenamebuf[200];
// ** GetGameParameter replacement functions
int Game_GetInventoryItemCount() {
// because of the dummy item 0, this is always one higher than it should be
return game.numinvitems - 1;
}
int Game_GetFontCount() {
return game.numfonts;
}
int Game_GetMouseCursorCount() {
return game.numcursors;
}
int Game_GetCharacterCount() {
return game.numcharacters;
}
int Game_GetGUICount() {
return game.numgui;
}
int Game_GetViewCount() {
return game.numviews;
}
int Game_GetSpriteWidth(int spriteNum) {
if (spriteNum < 0)
return 0;
if (!spriteset.DoesSpriteExist(spriteNum))
return 0;
return game.SpriteInfos[spriteNum].Width;
}
int Game_GetSpriteHeight(int spriteNum) {
if (spriteNum < 0)
return 0;
if (!spriteset.DoesSpriteExist(spriteNum))
return 0;
return game.SpriteInfos[spriteNum].Height;
}
int Game_GetLoopCountForView(int viewNumber) {
if ((viewNumber < 1) || (viewNumber > game.numviews))
quit("!GetGameParameter: invalid view specified");
return views[viewNumber - 1].numLoops;
}
int Game_GetRunNextSettingForLoop(int viewNumber, int loopNumber) {
if ((viewNumber < 1) || (viewNumber > game.numviews))
quit("!GetGameParameter: invalid view specified");
if ((loopNumber < 0) || (loopNumber >= views[viewNumber - 1].numLoops))
quit("!GetGameParameter: invalid loop specified");
return (views[viewNumber - 1].loops[loopNumber].RunNextLoop()) ? 1 : 0;
}
int Game_GetFrameCountForLoop(int viewNumber, int loopNumber) {
if ((viewNumber < 1) || (viewNumber > game.numviews))
quit("!GetGameParameter: invalid view specified");
if ((loopNumber < 0) || (loopNumber >= views[viewNumber - 1].numLoops))
quit("!GetGameParameter: invalid loop specified");
return views[viewNumber - 1].loops[loopNumber].numFrames;
}
ScriptViewFrame* Game_GetViewFrame(int viewNumber, int loopNumber, int frame) {
if ((viewNumber < 1) || (viewNumber > game.numviews))
quit("!GetGameParameter: invalid view specified");
if ((loopNumber < 0) || (loopNumber >= views[viewNumber - 1].numLoops))
quit("!GetGameParameter: invalid loop specified");
if ((frame < 0) || (frame >= views[viewNumber - 1].loops[loopNumber].numFrames))
quit("!GetGameParameter: invalid frame specified");
ScriptViewFrame *sdt = new ScriptViewFrame(viewNumber - 1, loopNumber, frame);
ccRegisterManagedObject(sdt, sdt);
return sdt;
}
int Game_DoOnceOnly(const char *token)
{
if (strlen(token) > 199)
quit("!Game.DoOnceOnly: token length cannot be more than 200 chars");
for (int i = 0; i < play.num_do_once_tokens; i++)
{
if (strcmp(play.do_once_tokens[i], token) == 0)
{
return 0;
}
}
play.do_once_tokens = (char**)realloc(play.do_once_tokens, sizeof(char*) * (play.num_do_once_tokens + 1));
play.do_once_tokens[play.num_do_once_tokens] = (char*)malloc(strlen(token) + 1);
strcpy(play.do_once_tokens[play.num_do_once_tokens], token);
play.num_do_once_tokens++;
return 1;
}
int Game_GetTextReadingSpeed()
{
return play.text_speed;
}
void Game_SetTextReadingSpeed(int newTextSpeed)
{
if (newTextSpeed < 1)
quitprintf("!Game.TextReadingSpeed: %d is an invalid speed", newTextSpeed);
play.text_speed = newTextSpeed;
}
int Game_GetMinimumTextDisplayTimeMs()
{
return play.text_min_display_time_ms;
}
void Game_SetMinimumTextDisplayTimeMs(int newTextMinTime)
{
play.text_min_display_time_ms = newTextMinTime;
}
int Game_GetIgnoreUserInputAfterTextTimeoutMs()
{
return play.ignore_user_input_after_text_timeout_ms;
}
void Game_SetIgnoreUserInputAfterTextTimeoutMs(int newValueMs)
{
play.ignore_user_input_after_text_timeout_ms = newValueMs;
}
const char *Game_GetFileName() {
return CreateNewScriptString(usetup.main_data_filename);
}
const char *Game_GetName() {
return CreateNewScriptString(play.game_name);
}
void Game_SetName(const char *newName) {
strncpy(play.game_name, newName, 99);
play.game_name[99] = 0;
#if (ALLEGRO_DATE > 19990103)
set_window_title(play.game_name);
#endif
}
int Game_GetSkippingCutscene()
{
if (play.fast_forward)
{
return 1;
}
return 0;
}
int Game_GetInSkippableCutscene()
{
if (play.in_cutscene)
{
return 1;
}
return 0;
}
int Game_GetColorFromRGB(int red, int grn, int blu) {
if ((red < 0) || (red > 255) || (grn < 0) || (grn > 255) ||
(blu < 0) || (blu > 255))
quit("!GetColorFromRGB: colour values must be 0-255");
if (game.color_depth == 1)
{
return makecol8(red, grn, blu);
}
int agscolor = ((blu >> 3) & 0x1f);
agscolor += ((grn >> 2) & 0x3f) << 5;
agscolor += ((red >> 3) & 0x1f) << 11;
return agscolor;
}
const char* Game_InputBox(const char *msg) {
char buffer[STD_BUFFER_SIZE];
sc_inputbox(msg, buffer);
return CreateNewScriptString(buffer);
}
const char* Game_GetLocationName(int x, int y) {
char buffer[STD_BUFFER_SIZE];
GetLocationName(x, y, buffer);
return CreateNewScriptString(buffer);
}
const char* Game_GetGlobalMessages(int index) {
if ((index < 500) || (index >= MAXGLOBALMES + 500)) {
return NULL;
}
char buffer[STD_BUFFER_SIZE];
buffer[0] = 0;
replace_tokens(get_translation(get_global_message(index)), buffer, STD_BUFFER_SIZE);
return CreateNewScriptString(buffer);
}
int Game_GetSpeechFont() {
return play.speech_font;
}
int Game_GetNormalFont() {
return play.normal_font;
}
const char* Game_GetTranslationFilename() {
char buffer[STD_BUFFER_SIZE];
GetTranslationName(buffer);
return CreateNewScriptString(buffer);
}
int Game_ChangeTranslation(const char *newFilename)
{
if ((newFilename == NULL) || (newFilename[0] == 0))
{
close_translation();
strcpy(transFileName, "");
return 1;
}
String oldTransFileName;
oldTransFileName = transFileName;
if (!init_translation(newFilename, oldTransFileName.LeftSection('.'), false))
{
strcpy(transFileName, oldTransFileName);
return 0;
}
return 1;
}
ScriptAudioClip *Game_GetAudioClip(int index)
{
if (index < 0 || index >= game.audioClipCount)
return NULL;
return &game.audioClips[index];
}
//=============================================================================
// save game functions
void serialize_bitmap(const Common::Bitmap *thispic, Stream *out) {
if (thispic != NULL) {
out->WriteInt32(thispic->GetWidth());
out->WriteInt32(thispic->GetHeight());
out->WriteInt32(thispic->GetColorDepth());
for (int cc=0;cc<thispic->GetHeight();cc++)
{
switch (thispic->GetColorDepth())
{
case 8:
// CHECKME: originally, AGS does not use real BPP here, but simply divides color depth by 8;
// therefore 15-bit bitmaps are saved only partially? is this a bug? or?
case 15:
out->WriteArray(&thispic->GetScanLine(cc)[0], thispic->GetWidth(), 1);
break;
case 16:
out->WriteArrayOfInt16((const int16_t*)&thispic->GetScanLine(cc)[0], thispic->GetWidth());
break;
case 32:
out->WriteArrayOfInt32((const int32_t*)&thispic->GetScanLine(cc)[0], thispic->GetWidth());
break;
}
}
}
}
// On Windows we could just use IIDFromString but this is platform-independant
void convert_guid_from_text_to_binary(const char *guidText, unsigned char *buffer)
{
guidText++; // skip {
for (int bytesDone = 0; bytesDone < 16; bytesDone++)
{
if (*guidText == '-')
guidText++;
char tempString[3];
tempString[0] = guidText[0];
tempString[1] = guidText[1];
tempString[2] = 0;
int thisByte = 0;
sscanf(tempString, "%X", &thisByte);
buffer[bytesDone] = thisByte;
guidText += 2;
}
// Swap bytes to give correct GUID order
unsigned char temp;
temp = buffer[0]; buffer[0] = buffer[3]; buffer[3] = temp;
temp = buffer[1]; buffer[1] = buffer[2]; buffer[2] = temp;
temp = buffer[4]; buffer[4] = buffer[5]; buffer[5] = temp;
temp = buffer[6]; buffer[6] = buffer[7]; buffer[7] = temp;
}
Bitmap *read_serialized_bitmap(Stream *in) {
Bitmap *thispic;
int picwid = in->ReadInt32();
int pichit = in->ReadInt32();
int piccoldep = in->ReadInt32();
thispic = BitmapHelper::CreateBitmap(picwid,pichit,piccoldep);
if (thispic == NULL)
return NULL;
for (int vv=0; vv < pichit; vv++)
{
switch (piccoldep)
{
case 8:
// CHECKME: originally, AGS does not use real BPP here, but simply divides color depth by 8
case 15:
in->ReadArray(thispic->GetScanLineForWriting(vv), picwid, 1);
break;
case 16:
in->ReadArrayOfInt16((int16_t*)thispic->GetScanLineForWriting(vv), picwid);
break;
case 32:
in->ReadArrayOfInt32((int32_t*)thispic->GetScanLineForWriting(vv), picwid);
break;
}
}
return thispic;
}
void skip_serialized_bitmap(Stream *in)
{
int picwid = in->ReadInt32();
int pichit = in->ReadInt32();
int piccoldep = in->ReadInt32();
// CHECKME: originally, AGS does not use real BPP here, but simply divides color depth by 8
int bpp = piccoldep / 8;
in->Seek(picwid * pichit * bpp);
}
long write_screen_shot_for_vista(Stream *out, Bitmap *screenshot)
{
long fileSize = 0;
char tempFileName[MAX_PATH];
sprintf(tempFileName, "%s""_tmpscht.bmp", saveGameDirectory);
screenshot->SaveToFile(tempFileName, palette);
update_polled_stuff_if_runtime();
if (exists(tempFileName))
{
fileSize = file_size_ex(tempFileName);
char *buffer = (char*)malloc(fileSize);
Stream *temp_in = Common::File::OpenFileRead(tempFileName);
temp_in->Read(buffer, fileSize);
delete temp_in;
unlink(tempFileName);
out->Write(buffer, fileSize);
free(buffer);
}
return fileSize;
}
void WriteGameSetupStructBase_Aligned(Stream *out)
{
AlignedStream align_s(out, Common::kAligned_Write);
game.GameSetupStructBase::WriteToFile(&align_s);
}
#define MAGICNUMBER 0xbeefcafe
void create_savegame_screenshot(Bitmap *&screenShot)
{
if (game.options[OPT_SAVESCREENSHOT]) {
int usewid = play.screenshot_width;
int usehit = play.screenshot_height;
if (usewid > virtual_screen->GetWidth())
usewid = virtual_screen->GetWidth();
if (usehit > virtual_screen->GetHeight())
usehit = virtual_screen->GetHeight();
if ((play.screenshot_width < 16) || (play.screenshot_height < 16))
quit("!Invalid game.screenshot_width/height, must be from 16x16 to screen res");
if (gfxDriver->UsesMemoryBackBuffer())
{
screenShot = BitmapHelper::CreateBitmap(usewid, usehit, virtual_screen->GetColorDepth());
screenShot->StretchBlt(virtual_screen,
RectWH(0, 0, virtual_screen->GetWidth(), virtual_screen->GetHeight()),
RectWH(0, 0, screenShot->GetWidth(), screenShot->GetHeight()));
}
else
{
// FIXME this weird stuff! (related to incomplete OpenGL renderer)
#if defined(IOS_VERSION) || defined(ANDROID_VERSION)
int color_depth = (psp_gfx_renderer > 0) ? 32 : game.GetColorDepth();
#else
int color_depth = game.GetColorDepth();
#endif
Bitmap *tempBlock = BitmapHelper::CreateBitmap(virtual_screen->GetWidth(), virtual_screen->GetHeight(), color_depth);
gfxDriver->GetCopyOfScreenIntoBitmap(tempBlock);
screenShot = BitmapHelper::CreateBitmap(usewid, usehit, color_depth);
screenShot->StretchBlt(tempBlock,
RectWH(0, 0, tempBlock->GetWidth(), tempBlock->GetHeight()),
RectWH(0, 0, screenShot->GetWidth(), screenShot->GetHeight()));
delete tempBlock;
}
}
}
void save_game(int slotn, const char*descript) {
// dont allow save in rep_exec_always, because we dont save
// the state of blocked scripts
can_run_delayed_command();
if (inside_script) {
strcpy(curscript->postScriptSaveSlotDescription[curscript->queue_action(ePSASaveGame, slotn, "SaveGameSlot")], descript);
return;
}
if (platform->GetDiskFreeSpaceMB() < 2) {
Display("ERROR: There is not enough disk space free to save the game. Clear some disk space and try again.");
return;
}
VALIDATE_STRING(descript);
String nametouse;
nametouse = get_save_game_path(slotn);
Bitmap *screenShot = NULL;
// Screenshot
create_savegame_screenshot(screenShot);
Common::PStream out = StartSavegame(nametouse, descript, screenShot);
if (out == NULL)
quit("save_game: unable to open savegame file for writing");
update_polled_stuff_if_runtime();
// Actual dynamic game data is saved here
SaveGameState(out);
if (screenShot != NULL)
{
int screenShotOffset = out->GetPosition() - sizeof(RICH_GAME_MEDIA_HEADER);
int screenShotSize = write_screen_shot_for_vista(out.get(), screenShot);
update_polled_stuff_if_runtime();
out.reset(Common::File::OpenFile(nametouse, Common::kFile_Open, Common::kFile_ReadWrite));
out->Seek(12, kSeekBegin);
out->WriteInt32(screenShotOffset);
out->Seek(4);
out->WriteInt32(screenShotSize);
}
if (screenShot != NULL)
delete screenShot;
}
char rbuffer[200];
HSaveError restore_game_head_dynamic_values(Stream *in, RestoredData &r_data)
{
r_data.FPS = in->ReadInt32();
r_data.CursorMode = in->ReadInt32();
r_data.CursorID = in->ReadInt32();
offsetx = in->ReadInt32();
offsety = in->ReadInt32();
loopcounter = in->ReadInt32();
return HSaveError::None();
}
void restore_game_spriteset(Stream *in)
{
// ensure the sprite set is at least as large as it was
// when the game was saved
spriteset.EnlargeTo(in->ReadInt32());
// get serialized dynamic sprites
int sprnum = in->ReadInt32();
while (sprnum) {
unsigned char spriteflag = in->ReadByte();
add_dynamic_sprite(sprnum, read_serialized_bitmap(in));
game.SpriteInfos[sprnum].Flags = spriteflag;
sprnum = in->ReadInt32();
}
}
HSaveError restore_game_scripts(Stream *in, const PreservedParams &pp, RestoredData &r_data)
{
// read the global script data segment
int gdatasize = in->ReadInt32();
if (pp.GlScDataSize != gdatasize)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Mismatching size of global script data.");
}
r_data.GlobalScript.Len = gdatasize;
r_data.GlobalScript.Data.reset(new char[gdatasize]);
in->Read(r_data.GlobalScript.Data.get(), gdatasize);
if (in->ReadInt32() != numScriptModules)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Mismatching number of script modules.");
}
r_data.ScriptModules.resize(numScriptModules);
for (int i = 0; i < numScriptModules; ++i)
{
size_t module_size = in->ReadInt32();
if (pp.ScMdDataSize[i] != module_size)
{
return new SavegameError(kSvgErr_GameContentAssertion, String::FromFormat("Mismatching size of script module data, module %d.", i));
}
r_data.ScriptModules[i].Len = module_size;
r_data.ScriptModules[i].Data.reset(new char[module_size]);
in->Read(r_data.ScriptModules[i].Data.get(), module_size);
}
return HSaveError::None();
}
void ReadRoomStatus_Aligned(RoomStatus *roomstat, Stream *in)
{
AlignedStream align_s(in, Common::kAligned_Read);
roomstat->ReadFromFile_v321(&align_s);
}
void restore_game_room_state(Stream *in)
{
int vv;
displayed_room = in->ReadInt32();
// read the room state for all the rooms the player has been in
RoomStatus* roomstat;
int beenhere;
for (vv=0;vv<MAX_ROOMS;vv++)
{
beenhere = in->ReadByte();
if (beenhere)
{
roomstat = getRoomStatus(vv);
roomstat->beenhere = beenhere;
if (roomstat->beenhere)
{
ReadRoomStatus_Aligned(roomstat, in);
if (roomstat->tsdatasize > 0)
{
roomstat->tsdata=(char*)malloc(roomstat->tsdatasize + 8); // JJS: Why allocate 8 additional bytes?
in->Read(&roomstat->tsdata[0], roomstat->tsdatasize);
}
}
}
}
}
void ReadGameState_Aligned(Stream *in)
{
AlignedStream align_s(in, Common::kAligned_Read);
play.ReadFromSavegame(&align_s, true);
}
void restore_game_play_ex_data(Stream *in)
{
if (play.num_do_once_tokens > 0)
{
play.do_once_tokens = (char**)malloc(sizeof(char*) * play.num_do_once_tokens);
for (int bb = 0; bb < play.num_do_once_tokens; bb++)
{
fgetstring_limit(rbuffer, in, 200);
play.do_once_tokens[bb] = (char*)malloc(strlen(rbuffer) + 1);
strcpy(play.do_once_tokens[bb], rbuffer);
}
}
in->ReadArrayOfInt32(&play.gui_draw_order[0], game.numgui);
}
void restore_game_play(Stream *in)
{
// preserve the replay settings
int playback_was = play.playback, recording_was = play.recording;
int gamestep_was = play.gamestep;
int screenfadedout_was = play.screen_is_faded_out;
int roomchanges_was = play.room_changes;
// make sure the pointer is preserved
int *gui_draw_order_was = play.gui_draw_order;
ReadGameState_Aligned(in);
play.screen_is_faded_out = screenfadedout_was;
play.playback = playback_was;
play.recording = recording_was;
play.gamestep = gamestep_was;
play.room_changes = roomchanges_was;
play.gui_draw_order = gui_draw_order_was;
restore_game_play_ex_data(in);
}
void ReadMoveList_Aligned(Stream *in)
{
AlignedStream align_s(in, Common::kAligned_Read);
for (int i = 0; i < game.numcharacters + MAX_ROOM_OBJECTS + 1; ++i)
{
mls[i].ReadFromFile_Legacy(&align_s);
align_s.Reset();
}
}
void ReadGameSetupStructBase_Aligned(Stream *in)
{
AlignedStream align_s(in, Common::kAligned_Read);
game.GameSetupStructBase::ReadFromFile(&align_s);
}
void ReadCharacterExtras_Aligned(Stream *in)
{
AlignedStream align_s(in, Common::kAligned_Read);
for (int i = 0; i < game.numcharacters; ++i)
{
charextra[i].ReadFromFile(&align_s);
align_s.Reset();
}
}
void restore_game_palette(Stream *in)
{
in->ReadArray(&palette[0],sizeof(color),256);
}
void restore_game_dialogs(Stream *in)
{
for (int vv=0;vv<game.numdialog;vv++)
in->ReadArrayOfInt32(&dialog[vv].optionflags[0],MAXTOPICOPTIONS);
}
void restore_game_more_dynamic_values(Stream *in)
{
mouse_on_iface=in->ReadInt32();
in->ReadInt32(); // mouse_on_iface_button
in->ReadInt32(); // mouse_pushed_iface
ifacepopped = in->ReadInt32();
game_paused=in->ReadInt32();
}
void ReadAnimatedButtons_Aligned(Stream *in)
{
AlignedStream align_s(in, Common::kAligned_Read);
for (int i = 0; i < numAnimButs; ++i)
{
animbuts[i].ReadFromFile(&align_s);
align_s.Reset();
}
}
HSaveError restore_game_gui(Stream *in, int numGuisWas)
{
GUI::ReadGUI(guis, in);
game.numgui = guis.size();
if (numGuisWas != game.numgui)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Mismatching number of GUI.");
}
numAnimButs = in->ReadInt32();
ReadAnimatedButtons_Aligned(in);
return HSaveError::None();
}
HSaveError restore_game_audiocliptypes(Stream *in)
{
if (in->ReadInt32() != game.audioClipTypeCount)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Mismatching number of Audio Clip Types.");
}
for (int i = 0; i < game.audioClipTypeCount; ++i)
{
game.audioClipTypes[i].ReadFromFile(in);
}
return HSaveError::None();
}
void restore_game_thisroom(Stream *in, RestoredData &r_data)
{
in->ReadArrayOfInt16(r_data.RoomLightLevels, MAX_ROOM_REGIONS);
in->ReadArrayOfInt32(r_data.RoomTintLevels, MAX_ROOM_REGIONS);
in->ReadArrayOfInt16(r_data.RoomZoomLevels1, MAX_WALK_AREAS + 1);
in->ReadArrayOfInt16(r_data.RoomZoomLevels2, MAX_WALK_AREAS + 1);
}
void restore_game_ambientsounds(Stream *in, RestoredData &r_data)
{
int bb;
for (int i = 0; i < MAX_SOUND_CHANNELS; ++i)
{
ambient[i].ReadFromFile(in);
}
for (bb = 1; bb < MAX_SOUND_CHANNELS; bb++) {
if (ambient[bb].channel == 0)
r_data.DoAmbient[bb] = 0;
else {
r_data.DoAmbient[bb] = ambient[bb].num;
ambient[bb].channel = 0;
}
}
}
void ReadOverlays_Aligned(Stream *in)
{
AlignedStream align_s(in, Common::kAligned_Read);
for (int i = 0; i < numscreenover; ++i)
{
screenover[i].ReadFromFile(&align_s);
align_s.Reset();
}
}
void restore_game_overlays(Stream *in)
{
numscreenover = in->ReadInt32();
ReadOverlays_Aligned(in);
for (int bb=0;bb<numscreenover;bb++) {
if (screenover[bb].hasSerializedBitmap)
screenover[bb].pic = read_serialized_bitmap(in);
}
}
void restore_game_dynamic_surfaces(Stream *in, RestoredData &r_data)
{
// load into a temp array since ccUnserialiseObjects will destroy
// it otherwise
r_data.DynamicSurfaces.resize(MAX_DYNAMIC_SURFACES);
for (int i = 0; i < MAX_DYNAMIC_SURFACES; ++i)
{
if (in->ReadInt8() == 0)
{
r_data.DynamicSurfaces[i] = NULL;
}
else
{
r_data.DynamicSurfaces[i] = read_serialized_bitmap(in);
}
}
}
void restore_game_displayed_room_status(Stream *in, RestoredData &r_data)
{
int bb;
for (bb = 0; bb < MAX_ROOM_BGFRAMES; bb++)
r_data.RoomBkgScene[bb].reset();
if (displayed_room >= 0) {
for (bb = 0; bb < MAX_ROOM_BGFRAMES; bb++) {
r_data.RoomBkgScene[bb] = NULL;
if (play.raw_modified[bb]) {
r_data.RoomBkgScene[bb].reset(read_serialized_bitmap(in));
}
}
bb = in->ReadInt32();
if (bb)
raw_saved_screen = read_serialized_bitmap(in);
// get the current troom, in case they save in room 600 or whatever
ReadRoomStatus_Aligned(&troom, in);
if (troom.tsdatasize > 0) {
troom.tsdata=(char*)malloc(troom.tsdatasize+5);
in->Read(&troom.tsdata[0],troom.tsdatasize);
}
else
troom.tsdata = NULL;
}
}
HSaveError restore_game_globalvars(Stream *in)
{
if (in->ReadInt32() != numGlobalVars)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Restore game error: mismatching number of Global Variables.");
}
for (int i = 0; i < numGlobalVars; ++i)
{
globalvars[i].Read(in);
}
return HSaveError::None();
}
HSaveError restore_game_views(Stream *in)
{
if (in->ReadInt32() != game.numviews)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Mismatching number of Views.");
}
for (int bb = 0; bb < game.numviews; bb++) {
for (int cc = 0; cc < views[bb].numLoops; cc++) {
for (int dd = 0; dd < views[bb].loops[cc].numFrames; dd++)
{
views[bb].loops[cc].frames[dd].sound = in->ReadInt32();
views[bb].loops[cc].frames[dd].pic = in->ReadInt32();
}
}
}
return HSaveError::None();
}
HSaveError restore_game_audioclips_and_crossfade(Stream *in, RestoredData &r_data)
{
if (in->ReadInt32() != game.audioClipCount)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Mismatching number of Audio Clips.");
}
for (int i = 0; i <= MAX_SOUND_CHANNELS; ++i)
{
RestoredData::ChannelInfo &chan_info = r_data.AudioChans[i];
chan_info.Pos = 0;
chan_info.ClipID = in->ReadInt32();
if (chan_info.ClipID >= 0)
{
if (chan_info.ClipID >= game.audioClipCount)
{
return new SavegameError(kSvgErr_GameObjectInitFailed, "Invalid audio clip index.");
}
chan_info.Pos = in->ReadInt32();
if (chan_info.Pos < 0)
chan_info.Pos = 0;
chan_info.Priority = in->ReadInt32();
chan_info.Repeat = in->ReadInt32();
chan_info.Vol = in->ReadInt32();
chan_info.Pan = in->ReadInt32();
chan_info.VolAsPercent = in->ReadInt32();
chan_info.PanAsPercent = in->ReadInt32();
chan_info.Speed = 1000;
chan_info.Speed = in->ReadInt32();
}
}
crossFading = in->ReadInt32();
crossFadeVolumePerStep = in->ReadInt32();
crossFadeStep = in->ReadInt32();
crossFadeVolumeAtStart = in->ReadInt32();
return HSaveError::None();
}
HSaveError restore_game_data(Stream *in, SavegameVersion svg_version, const PreservedParams &pp, RestoredData &r_data)
{
int vv;
HSaveError err = restore_game_head_dynamic_values(in, r_data);
if (!err)
return err;
restore_game_spriteset(in);
update_polled_stuff_if_runtime();
err = restore_game_scripts(in, pp, r_data);
if (!err)
return err;
restore_game_room_state(in);
restore_game_play(in);
ReadMoveList_Aligned(in);
// save pointer members before reading
char* gswas=game.globalscript;
ccScript* compsc=game.CompiledScript;
CharacterInfo* chwas=game.chars;
WordsDictionary *olddict = game.dict;
char* mesbk[MAXGLOBALMES];
int numchwas = game.numcharacters;
for (vv=0;vv<MAXGLOBALMES;vv++) mesbk[vv]=game.messages[vv];
int numdiwas = game.numdialog;
int numinvwas = game.numinvitems;
int numviewswas = game.numviews;
int numGuisWas = game.numgui;
ReadGameSetupStructBase_Aligned(in);
// Delete unneeded data
// TODO: reorganize this (may be solved by optimizing safe format too)
delete [] game.load_messages;
game.load_messages = NULL;
if (game.numdialog!=numdiwas)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Mismatching number of Dialogs.");
}
if (numchwas != game.numcharacters)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Mismatching number of Characters.");
}
if (numinvwas != game.numinvitems)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Mismatching number of Inventory Items.");
}
if (game.numviews != numviewswas)
{
return new SavegameError(kSvgErr_GameContentAssertion, "Mismatching number of Views.");
}
game.ReadFromSaveGame_v321(in, gswas, compsc, chwas, olddict, mesbk);
// Modified custom properties are read separately to keep existing save format
play.ReadCustomProperties_v340(in);
ReadCharacterExtras_Aligned(in);
restore_game_palette(in);
restore_game_dialogs(in);
restore_game_more_dynamic_values(in);
err = restore_game_gui(in, numGuisWas);
if (!err)
return err;
err = restore_game_audiocliptypes(in);
if (!err)
return err;
restore_game_thisroom(in, r_data);
restore_game_ambientsounds(in, r_data);
restore_game_overlays(in);
update_polled_stuff_if_runtime();
restore_game_dynamic_surfaces(in, r_data);
update_polled_stuff_if_runtime();
restore_game_displayed_room_status(in, r_data);
err = restore_game_globalvars(in);
if (!err)
return err;
err = restore_game_views(in);
if (!err)
return err;
if (in->ReadInt32() != MAGICNUMBER+1)
{
return new SavegameError(kSvgErr_InconsistentFormat, "MAGICNUMBER not found before Audio Clips.");
}
err = restore_game_audioclips_and_crossfade(in, r_data);
if (!err)
return err;
// [IKM] Plugins expect FILE pointer! // TODO something with this later
pl_run_plugin_hooks(AGSE_RESTOREGAME, (long)((Common::FileStream*)in)->GetHandle());
if (in->ReadInt32() != (unsigned)MAGICNUMBER)
return new SavegameError(kSvgErr_InconsistentPlugin);
// save the new room music vol for later use
r_data.RoomVolume = (RoomVolumeMod)in->ReadInt32();
if (ccUnserializeAllObjects(in, &ccUnserializer))
{
return new SavegameError(kSvgErr_GameObjectInitFailed,
String::FromFormat("Managed pool deserialization failed: %s.", ccErrorString));
}
// preserve legacy music type setting
current_music_type = in->ReadInt32();
return HSaveError::None();
}
int gameHasBeenRestored = 0;
int oldeip;
bool read_savedgame_description(const String &savedgame, String &description)
{
SavegameDescription desc;
if (OpenSavegame(savedgame, desc, kSvgDesc_UserText))
{
description = desc.UserText;
return true;
}
return false;
}
bool read_savedgame_screenshot(const String &savedgame, int &want_shot)
{
want_shot = 0;
SavegameDescription desc;
HSaveError err = OpenSavegame(savedgame, desc, kSvgDesc_UserImage);
if (!err)
return false;
if (desc.UserImage.get())
{
int slot = spriteset.AddNewSprite();
if (slot > 0)
{
// add it into the sprite set
add_dynamic_sprite(slot, ReplaceBitmapWithSupportedFormat(desc.UserImage.release()));
want_shot = slot;
}
}
return true;
}
HSaveError load_game(const String &path, int slotNumber, bool &data_overwritten)
{
data_overwritten = false;
gameHasBeenRestored++;
oldeip = our_eip;
our_eip = 2050;
HSaveError err;
SavegameSource src;
SavegameDescription desc;
err = OpenSavegame(path, src, desc, kSvgDesc_EnvInfo);
// saved in incompatible enviroment
if (!err)
return err;
// CHECKME: is this color depth test still essential? if yes, is there possible workaround?
else if (desc.ColorDepth != game.GetColorDepth())
return new SavegameError(kSvgErr_DifferentColorDepth, String::FromFormat("Running: %d-bit, saved in: %d-bit.", game.GetColorDepth(), desc.ColorDepth));
// saved with different game file
if (Path::ComparePaths(desc.MainDataFilename, usetup.main_data_filename))
{
// [IKM] 2012-11-26: this is a workaround, indeed.
// Try to find wanted game's executable; if it does not exist,
// continue loading savedgame in current game, and pray for the best
get_install_dir_path(gamefilenamebuf, desc.MainDataFilename);
if (Common::File::TestReadFile(gamefilenamebuf))
{
RunAGSGame (desc.MainDataFilename, 0, 0);
load_new_game_restore = slotNumber;
return HSaveError::None();
}
Common::Debug::Printf(kDbgMsg_Warn, "WARNING: the saved game '%s' references game file '%s', but it cannot be found in the current directory. Trying to restore in the running game instead.",
path.GetCStr(), desc.MainDataFilename.GetCStr());
}
// do the actual restore
err = RestoreGameState(src.InputStream, src.Version);
data_overwritten = true;
if (!err)
return err;
src.InputStream.reset();
our_eip = oldeip;
// ensure keyboard buffer is clean
// use the raw versions rather than the rec_ versions so we don't
// interfere with the replay sync
while (keypressed()) readkey();
// call "After Restore" event callback
run_on_event(GE_RESTORE_GAME, RuntimeScriptValue().SetInt32(slotNumber));
return HSaveError::None();
}
bool try_restore_save(int slot)
{
return try_restore_save(get_save_game_path(slot), slot);
}
bool try_restore_save(const Common::String &path, int slot)
{
bool data_overwritten;
HSaveError err = load_game(path, slot, data_overwritten);
if (!err)
{
String error = String::FromFormat("Unable to restore the saved game.\n%s",
err->FullMessage().GetCStr());
// currently AGS cannot properly revert to stable state if some of the
// game data was released or overwritten by the data from save file,
// this is why we tell engine to shutdown if that happened.
if (data_overwritten)
quitprintf(error);
else
Display(error);
return false;
}
return true;
}
void start_skipping_cutscene () {
play.fast_forward = 1;
// if a drop-down icon bar is up, remove it as it will pause the game
if (ifacepopped>=0)
remove_popup_interface(ifacepopped);
// if a text message is currently displayed, remove it
if (is_text_overlay > 0)
remove_screen_overlay(OVER_TEXTMSG);
}
void check_skip_cutscene_keypress (int kgn) {
if ((play.in_cutscene > 0) && (play.in_cutscene != 3)) {
if ((kgn != 27) && ((play.in_cutscene == 1) || (play.in_cutscene == 5)))
;
else
start_skipping_cutscene();
}
}
// Helper functions used by StartCutscene/EndCutscene, but also
// by SkipUntilCharacterStops
void initialize_skippable_cutscene() {
play.end_cutscene_music = -1;
}
void stop_fast_forwarding() {
// when the skipping of a cutscene comes to an end, update things
play.fast_forward = 0;
setpal();
if (play.end_cutscene_music >= 0)
newmusic(play.end_cutscene_music);
// Restore actual volume of sounds
for (int aa = 0; aa < MAX_SOUND_CHANNELS; aa++)
{
if ((channels[aa] != NULL) && (!channels[aa]->done))
{
channels[aa]->set_mute(false);
}
}
update_music_volume();
}
// allowHotspot0 defines whether Hotspot 0 returns LOCTYPE_HOTSPOT
// or whether it returns 0
int __GetLocationType(int xxx,int yyy, int allowHotspot0) {
getloctype_index = 0;
// If it's not in ProcessClick, then return 0 when over a GUI
if ((GetGUIAt(xxx, yyy) >= 0) && (getloctype_throughgui == 0))
return 0;
getloctype_throughgui = 0;
xxx += offsetx;
yyy += offsety;
if ((xxx>=thisroom.Width) | (xxx<0) | (yyy<0) | (yyy>=thisroom.Height))
return 0;
// check characters, objects and walkbehinds, work out which is
// foremost visible to the player
int charat = is_pos_on_character(xxx,yyy);
int hsat = get_hotspot_at(xxx,yyy);
int objat = GetObjectAt(xxx - offsetx, yyy - offsety);
int wbat = thisroom.WalkBehindMask->GetPixel(xxx, yyy);
if (wbat <= 0) wbat = 0;
else wbat = croom->walkbehind_base[wbat];
int winner = 0;
// if it's an Ignore Walkbehinds object, then ignore the walkbehind
if ((objat >= 0) && ((objs[objat].flags & OBJF_NOWALKBEHINDS) != 0))
wbat = 0;
if ((charat >= 0) && ((game.chars[charat].flags & CHF_NOWALKBEHINDS) != 0))
wbat = 0;
if ((charat >= 0) && (objat >= 0)) {
if ((wbat > obj_lowest_yp) && (wbat > char_lowest_yp))
winner = LOCTYPE_HOTSPOT;
else if (obj_lowest_yp > char_lowest_yp)
winner = LOCTYPE_OBJ;
else
winner = LOCTYPE_CHAR;
}
else if (charat >= 0) {
if (wbat > char_lowest_yp)
winner = LOCTYPE_HOTSPOT;
else
winner = LOCTYPE_CHAR;
}
else if (objat >= 0) {
if (wbat > obj_lowest_yp)
winner = LOCTYPE_HOTSPOT;
else
winner = LOCTYPE_OBJ;
}
if (winner == 0) {
if (hsat >= 0)
winner = LOCTYPE_HOTSPOT;
}
if ((winner == LOCTYPE_HOTSPOT) && (!allowHotspot0) && (hsat == 0))
winner = 0;
if (winner == LOCTYPE_HOTSPOT)
getloctype_index = hsat;
else if (winner == LOCTYPE_CHAR)
getloctype_index = charat;
else if (winner == LOCTYPE_OBJ)
getloctype_index = objat;
return winner;
}
// Called whenever game looses input focus
void display_switch_out()
{
switched_away = true;
clear_input_buffer();
// Always unlock mouse when switching out from the game
Mouse::UnlockFromWindow();
platform->DisplaySwitchOut();
platform->ExitFullscreenMode();
}
void display_switch_out_suspend()
{
// this is only called if in SWITCH_PAUSE mode
//debug_script_warn("display_switch_out");
display_switch_out();
switching_away_from_game++;
platform->PauseApplication();
// allow background running temporarily to halt the sound
if (set_display_switch_mode(SWITCH_BACKGROUND) == -1)
set_display_switch_mode(SWITCH_BACKAMNESIA);
// stop the sound stuttering
for (int i = 0; i <= MAX_SOUND_CHANNELS; i++) {
if ((channels[i] != NULL) && (channels[i]->done == 0)) {
channels[i]->pause();
}
}
rest(1000);
// restore the callbacks
SetMultitasking(0);
switching_away_from_game--;
}
// Called whenever game gets input focus
void display_switch_in()
{
switched_away = false;
if (gfxDriver)
{
DisplayMode mode = gfxDriver->GetDisplayMode();
if (!mode.Windowed)
platform->EnterFullscreenMode(mode);
}
platform->DisplaySwitchIn();
clear_input_buffer();
// If auto lock option is set, lock mouse to the game window
if (usetup.mouse_auto_lock && scsystem.windowed)
Mouse::TryLockToWindow();
}
void display_switch_in_resume()
{
display_switch_in();
for (int i = 0; i <= MAX_SOUND_CHANNELS; i++) {
if ((channels[i] != NULL) && (channels[i]->done == 0)) {
channels[i]->resume();
}
}
// This can cause a segfault on Linux
#if !defined (LINUX_VERSION)
if (gfxDriver->UsesMemoryBackBuffer()) // make sure all borders are cleared
gfxDriver->ClearRectangle(0, 0, game.size.Width - 1, game.size.Height - 1, NULL);
#endif
platform->ResumeApplication();
}
void replace_tokens(const char*srcmes,char*destm, int maxlen) {
int indxdest=0,indxsrc=0;
const char*srcp;
char *destp;
while (srcmes[indxsrc]!=0) {
srcp=&srcmes[indxsrc];
destp=&destm[indxdest];
if ((strncmp(srcp,"@IN",3)==0) | (strncmp(srcp,"@GI",3)==0)) {
int tokentype=0;
if (srcp[1]=='I') tokentype=1;
else tokentype=2;
int inx=atoi(&srcp[3]);
srcp++;
indxsrc+=2;
while (srcp[0]!='@') {
if (srcp[0]==0) quit("!Display: special token not terminated");
srcp++;
indxsrc++;
}
char tval[10];
if (tokentype==1) {
if ((inx<1) | (inx>=game.numinvitems))
quit("!Display: invalid inv item specified in @IN@");
sprintf(tval,"%d",playerchar->inv[inx]);
}
else {
if ((inx<0) | (inx>=MAXGSVALUES))
quit("!Display: invalid global int index speicifed in @GI@");
sprintf(tval,"%d",GetGlobalInt(inx));
}
strcpy(destp,tval);
indxdest+=strlen(tval);
}
else {
destp[0]=srcp[0];
indxdest++;
indxsrc++;
}
if (indxdest >= maxlen - 3)
break;
}
destm[indxdest]=0;
}
const char *get_global_message (int msnum) {
if (game.messages[msnum-500] == NULL)
return "";
return get_translation(game.messages[msnum-500]);
}
void get_message_text (int msnum, char *buffer, char giveErr) {
int maxlen = 9999;
if (!giveErr)
maxlen = MAX_MAXSTRLEN;
if (msnum>=500) { //quit("global message requseted, nto yet supported");
if ((msnum >= MAXGLOBALMES + 500) || (game.messages[msnum-500]==NULL)) {
if (giveErr)
quit("!DisplayGlobalMessage: message does not exist");
buffer[0] = 0;
return;
}
buffer[0] = 0;
replace_tokens(get_translation(game.messages[msnum-500]), buffer, maxlen);
return;
}
else if (msnum < 0 || (size_t)msnum >= thisroom.MessageCount) {
if (giveErr)
quit("!DisplayMessage: Invalid message number to display");
buffer[0] = 0;
return;
}
buffer[0]=0;
replace_tokens(get_translation(thisroom.Messages[msnum]), buffer, maxlen);
}
bool unserialize_audio_script_object(int index, const char *objectType, const char *serializedData, int dataSize)
{
if (strcmp(objectType, "AudioChannel") == 0)
{
ccDynamicAudio.Unserialize(index, serializedData, dataSize);
}
else if (strcmp(objectType, "AudioClip") == 0)
{
ccDynamicAudioClip.Unserialize(index, serializedData, dataSize);
}
else
{
return false;
}
return true;
}
//=============================================================================
//
// Script API Functions
//
//=============================================================================
#include "debug/out.h"
#include "script/script_api.h"
#include "script/script_runtime.h"
// int (int audioType);
RuntimeScriptValue Sc_Game_IsAudioPlaying(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT_PINT(Game_IsAudioPlaying);
}
// void (int audioType, int volumeDrop)
RuntimeScriptValue Sc_Game_SetAudioTypeSpeechVolumeDrop(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_PINT2(Game_SetAudioTypeSpeechVolumeDrop);
}
// void (int audioType, int volume, int changeType)
RuntimeScriptValue Sc_Game_SetAudioTypeVolume(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_PINT3(Game_SetAudioTypeVolume);
}
// void (int audioType)
RuntimeScriptValue Sc_Game_StopAudio(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_PINT(Game_StopAudio);
}
// int (const char *newFilename)
RuntimeScriptValue Sc_Game_ChangeTranslation(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT_POBJ(Game_ChangeTranslation, const char);
}
// int (const char *token)
RuntimeScriptValue Sc_Game_DoOnceOnly(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT_POBJ(Game_DoOnceOnly, const char);
}
// int (int red, int grn, int blu)
RuntimeScriptValue Sc_Game_GetColorFromRGB(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT_PINT3(Game_GetColorFromRGB);
}
// int (int viewNumber, int loopNumber)
RuntimeScriptValue Sc_Game_GetFrameCountForLoop(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT_PINT2(Game_GetFrameCountForLoop);
}
// const char* (int x, int y)
RuntimeScriptValue Sc_Game_GetLocationName(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_OBJ_PINT2(const char, myScriptStringImpl, Game_GetLocationName);
}
// int (int viewNumber)
RuntimeScriptValue Sc_Game_GetLoopCountForView(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT_PINT(Game_GetLoopCountForView);
}
// int ()
RuntimeScriptValue Sc_Game_GetMODPattern(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetMODPattern);
}
// int (int viewNumber, int loopNumber)
RuntimeScriptValue Sc_Game_GetRunNextSettingForLoop(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT_PINT2(Game_GetRunNextSettingForLoop);
}
// const char* (int slnum)
RuntimeScriptValue Sc_Game_GetSaveSlotDescription(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_OBJ_PINT(const char, myScriptStringImpl, Game_GetSaveSlotDescription);
}
// ScriptViewFrame* (int viewNumber, int loopNumber, int frame)
RuntimeScriptValue Sc_Game_GetViewFrame(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_OBJAUTO_PINT3(ScriptViewFrame, Game_GetViewFrame);
}
// const char* (const char *msg)
RuntimeScriptValue Sc_Game_InputBox(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_OBJ_POBJ(const char, myScriptStringImpl, Game_InputBox, const char);
}
// int (const char *newFolder)
RuntimeScriptValue Sc_Game_SetSaveGameDirectory(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT_POBJ(Game_SetSaveGameDirectory, const char);
}
// void (int evenAmbient);
RuntimeScriptValue Sc_StopAllSounds(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_PINT(StopAllSounds);
}
// int ()
RuntimeScriptValue Sc_Game_GetCharacterCount(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetCharacterCount);
}
// int ()
RuntimeScriptValue Sc_Game_GetDialogCount(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetDialogCount);
}
// const char *()
RuntimeScriptValue Sc_Game_GetFileName(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_OBJ(const char, myScriptStringImpl, Game_GetFileName);
}
// int ()
RuntimeScriptValue Sc_Game_GetFontCount(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetFontCount);
}
// const char* (int index)
RuntimeScriptValue Sc_Game_GetGlobalMessages(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_OBJ_PINT(const char, myScriptStringImpl, Game_GetGlobalMessages);
}
/*
// [DEPRECATED] const char* (int index)
RuntimeScriptValue Sc_Game_GetGlobalStrings(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_OBJ_PINT(const char, myScriptStringImpl, Game_GetGlobalStrings);
}
*/
/*
// [DEPRECATED] void (int index, char *newval);
RuntimeScriptValue Sc_SetGlobalString(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_PINT_POBJ(SetGlobalString, const char);
}
*/
// int ()
RuntimeScriptValue Sc_Game_GetGUICount(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetGUICount);
}
// int ()
RuntimeScriptValue Sc_Game_GetIgnoreUserInputAfterTextTimeoutMs(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetIgnoreUserInputAfterTextTimeoutMs);
}
// void (int newValueMs)
RuntimeScriptValue Sc_Game_SetIgnoreUserInputAfterTextTimeoutMs(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_PINT(Game_SetIgnoreUserInputAfterTextTimeoutMs);
}
// int ()
RuntimeScriptValue Sc_Game_GetInSkippableCutscene(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetInSkippableCutscene);
}
// int ()
RuntimeScriptValue Sc_Game_GetInventoryItemCount(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetInventoryItemCount);
}
// int ()
RuntimeScriptValue Sc_Game_GetMinimumTextDisplayTimeMs(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetMinimumTextDisplayTimeMs);
}
// void (int newTextMinTime)
RuntimeScriptValue Sc_Game_SetMinimumTextDisplayTimeMs(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_PINT(Game_SetMinimumTextDisplayTimeMs);
}
// int ()
RuntimeScriptValue Sc_Game_GetMouseCursorCount(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetMouseCursorCount);
}
// const char *()
RuntimeScriptValue Sc_Game_GetName(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_OBJ(const char, myScriptStringImpl, Game_GetName);
}
// void (const char *newName)
RuntimeScriptValue Sc_Game_SetName(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_POBJ(Game_SetName, const char);
}
// int ()
RuntimeScriptValue Sc_Game_GetNormalFont(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetNormalFont);
}
// void (int fontnum);
RuntimeScriptValue Sc_SetNormalFont(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_PINT(SetNormalFont);
}
// int ()
RuntimeScriptValue Sc_Game_GetSkippingCutscene(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetSkippingCutscene);
}
// int ()
RuntimeScriptValue Sc_Game_GetSpeechFont(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetSpeechFont);
}
// void (int fontnum);
RuntimeScriptValue Sc_SetSpeechFont(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_PINT(SetSpeechFont);
}
// int (int spriteNum)
RuntimeScriptValue Sc_Game_GetSpriteWidth(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT_PINT(Game_GetSpriteWidth);
}
// int (int spriteNum)
RuntimeScriptValue Sc_Game_GetSpriteHeight(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT_PINT(Game_GetSpriteHeight);
}
// int ()
RuntimeScriptValue Sc_Game_GetTextReadingSpeed(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetTextReadingSpeed);
}
// void (int newTextSpeed)
RuntimeScriptValue Sc_Game_SetTextReadingSpeed(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_VOID_PINT(Game_SetTextReadingSpeed);
}
// const char* ()
RuntimeScriptValue Sc_Game_GetTranslationFilename(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_OBJ(const char, myScriptStringImpl, Game_GetTranslationFilename);
}
// int ()
RuntimeScriptValue Sc_Game_GetViewCount(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_INT(Game_GetViewCount);
}
RuntimeScriptValue Sc_Game_GetAudioClipCount(const RuntimeScriptValue *params, int32_t param_count)
{
API_VARGET_INT(game.audioClipCount);
}
RuntimeScriptValue Sc_Game_GetAudioClip(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_OBJ_PINT(ScriptAudioClip, ccDynamicAudioClip, Game_GetAudioClip);
}
RuntimeScriptValue Sc_Game_IsPluginLoaded(const RuntimeScriptValue *params, int32_t param_count)
{
API_SCALL_BOOL_OBJ(pl_is_plugin_loaded, const char);
}
void RegisterGameAPI()
{
ccAddExternalStaticFunction("Game::IsAudioPlaying^1", Sc_Game_IsAudioPlaying);
ccAddExternalStaticFunction("Game::SetAudioTypeSpeechVolumeDrop^2", Sc_Game_SetAudioTypeSpeechVolumeDrop);
ccAddExternalStaticFunction("Game::SetAudioTypeVolume^3", Sc_Game_SetAudioTypeVolume);
ccAddExternalStaticFunction("Game::StopAudio^1", Sc_Game_StopAudio);
ccAddExternalStaticFunction("Game::ChangeTranslation^1", Sc_Game_ChangeTranslation);
ccAddExternalStaticFunction("Game::DoOnceOnly^1", Sc_Game_DoOnceOnly);
ccAddExternalStaticFunction("Game::GetColorFromRGB^3", Sc_Game_GetColorFromRGB);
ccAddExternalStaticFunction("Game::GetFrameCountForLoop^2", Sc_Game_GetFrameCountForLoop);
ccAddExternalStaticFunction("Game::GetLocationName^2", Sc_Game_GetLocationName);
ccAddExternalStaticFunction("Game::GetLoopCountForView^1", Sc_Game_GetLoopCountForView);
ccAddExternalStaticFunction("Game::GetMODPattern^0", Sc_Game_GetMODPattern);
ccAddExternalStaticFunction("Game::GetRunNextSettingForLoop^2", Sc_Game_GetRunNextSettingForLoop);
ccAddExternalStaticFunction("Game::GetSaveSlotDescription^1", Sc_Game_GetSaveSlotDescription);
ccAddExternalStaticFunction("Game::GetViewFrame^3", Sc_Game_GetViewFrame);
ccAddExternalStaticFunction("Game::InputBox^1", Sc_Game_InputBox);
ccAddExternalStaticFunction("Game::SetSaveGameDirectory^1", Sc_Game_SetSaveGameDirectory);
ccAddExternalStaticFunction("Game::StopSound^1", Sc_StopAllSounds);
ccAddExternalStaticFunction("Game::get_CharacterCount", Sc_Game_GetCharacterCount);
ccAddExternalStaticFunction("Game::get_DialogCount", Sc_Game_GetDialogCount);
ccAddExternalStaticFunction("Game::get_FileName", Sc_Game_GetFileName);
ccAddExternalStaticFunction("Game::get_FontCount", Sc_Game_GetFontCount);
ccAddExternalStaticFunction("Game::geti_GlobalMessages", Sc_Game_GetGlobalMessages);
//ccAddExternalStaticFunction("Game::geti_GlobalStrings", Sc_Game_GetGlobalStrings);// [DEPRECATED]
//ccAddExternalStaticFunction("Game::seti_GlobalStrings", Sc_SetGlobalString);// [DEPRECATED]
ccAddExternalStaticFunction("Game::get_GUICount", Sc_Game_GetGUICount);
ccAddExternalStaticFunction("Game::get_IgnoreUserInputAfterTextTimeoutMs", Sc_Game_GetIgnoreUserInputAfterTextTimeoutMs);
ccAddExternalStaticFunction("Game::set_IgnoreUserInputAfterTextTimeoutMs", Sc_Game_SetIgnoreUserInputAfterTextTimeoutMs);
ccAddExternalStaticFunction("Game::get_InSkippableCutscene", Sc_Game_GetInSkippableCutscene);
ccAddExternalStaticFunction("Game::get_InventoryItemCount", Sc_Game_GetInventoryItemCount);
ccAddExternalStaticFunction("Game::get_MinimumTextDisplayTimeMs", Sc_Game_GetMinimumTextDisplayTimeMs);
ccAddExternalStaticFunction("Game::set_MinimumTextDisplayTimeMs", Sc_Game_SetMinimumTextDisplayTimeMs);
ccAddExternalStaticFunction("Game::get_MouseCursorCount", Sc_Game_GetMouseCursorCount);
ccAddExternalStaticFunction("Game::get_Name", Sc_Game_GetName);
ccAddExternalStaticFunction("Game::set_Name", Sc_Game_SetName);
ccAddExternalStaticFunction("Game::get_NormalFont", Sc_Game_GetNormalFont);
ccAddExternalStaticFunction("Game::set_NormalFont", Sc_SetNormalFont);
ccAddExternalStaticFunction("Game::get_SkippingCutscene", Sc_Game_GetSkippingCutscene);
ccAddExternalStaticFunction("Game::get_SpeechFont", Sc_Game_GetSpeechFont);
ccAddExternalStaticFunction("Game::set_SpeechFont", Sc_SetSpeechFont);
ccAddExternalStaticFunction("Game::geti_SpriteWidth", Sc_Game_GetSpriteWidth);
ccAddExternalStaticFunction("Game::geti_SpriteHeight", Sc_Game_GetSpriteHeight);
ccAddExternalStaticFunction("Game::get_TextReadingSpeed", Sc_Game_GetTextReadingSpeed);
ccAddExternalStaticFunction("Game::set_TextReadingSpeed", Sc_Game_SetTextReadingSpeed);
ccAddExternalStaticFunction("Game::get_TranslationFilename", Sc_Game_GetTranslationFilename);
ccAddExternalStaticFunction("Game::get_ViewCount", Sc_Game_GetViewCount);
ccAddExternalStaticFunction("Game::get_AudioClipCount", Sc_Game_GetAudioClipCount);
ccAddExternalStaticFunction("Game::geti_AudioClips", Sc_Game_GetAudioClip);
ccAddExternalStaticFunction("Game::IsPluginLoaded", Sc_Game_IsPluginLoaded);
/* ----------------------- Registering unsafe exports for plugins -----------------------*/
ccAddExternalFunctionForPlugin("Game::IsAudioPlaying^1", (void*)Game_IsAudioPlaying);
ccAddExternalFunctionForPlugin("Game::SetAudioTypeSpeechVolumeDrop^2", (void*)Game_SetAudioTypeSpeechVolumeDrop);
ccAddExternalFunctionForPlugin("Game::SetAudioTypeVolume^3", (void*)Game_SetAudioTypeVolume);
ccAddExternalFunctionForPlugin("Game::StopAudio^1", (void*)Game_StopAudio);
ccAddExternalFunctionForPlugin("Game::ChangeTranslation^1", (void*)Game_ChangeTranslation);
ccAddExternalFunctionForPlugin("Game::DoOnceOnly^1", (void*)Game_DoOnceOnly);
ccAddExternalFunctionForPlugin("Game::GetColorFromRGB^3", (void*)Game_GetColorFromRGB);
ccAddExternalFunctionForPlugin("Game::GetFrameCountForLoop^2", (void*)Game_GetFrameCountForLoop);
ccAddExternalFunctionForPlugin("Game::GetLocationName^2", (void*)Game_GetLocationName);
ccAddExternalFunctionForPlugin("Game::GetLoopCountForView^1", (void*)Game_GetLoopCountForView);
ccAddExternalFunctionForPlugin("Game::GetMODPattern^0", (void*)Game_GetMODPattern);
ccAddExternalFunctionForPlugin("Game::GetRunNextSettingForLoop^2", (void*)Game_GetRunNextSettingForLoop);
ccAddExternalFunctionForPlugin("Game::GetSaveSlotDescription^1", (void*)Game_GetSaveSlotDescription);
ccAddExternalFunctionForPlugin("Game::GetViewFrame^3", (void*)Game_GetViewFrame);
ccAddExternalFunctionForPlugin("Game::InputBox^1", (void*)Game_InputBox);
ccAddExternalFunctionForPlugin("Game::SetSaveGameDirectory^1", (void*)Game_SetSaveGameDirectory);
ccAddExternalFunctionForPlugin("Game::StopSound^1", (void*)StopAllSounds);
ccAddExternalFunctionForPlugin("Game::get_CharacterCount", (void*)Game_GetCharacterCount);
ccAddExternalFunctionForPlugin("Game::get_DialogCount", (void*)Game_GetDialogCount);
ccAddExternalFunctionForPlugin("Game::get_FileName", (void*)Game_GetFileName);
ccAddExternalFunctionForPlugin("Game::get_FontCount", (void*)Game_GetFontCount);
ccAddExternalFunctionForPlugin("Game::geti_GlobalMessages", (void*)Game_GetGlobalMessages);
//ccAddExternalFunctionForPlugin("Game::geti_GlobalStrings", (void*)Game_GetGlobalStrings);// [DEPRECATED]
//ccAddExternalFunctionForPlugin("Game::seti_GlobalStrings", (void*)SetGlobalString);// [DEPRECATED]
ccAddExternalFunctionForPlugin("Game::get_GUICount", (void*)Game_GetGUICount);
ccAddExternalFunctionForPlugin("Game::get_IgnoreUserInputAfterTextTimeoutMs", (void*)Game_GetIgnoreUserInputAfterTextTimeoutMs);
ccAddExternalFunctionForPlugin("Game::set_IgnoreUserInputAfterTextTimeoutMs", (void*)Game_SetIgnoreUserInputAfterTextTimeoutMs);
ccAddExternalFunctionForPlugin("Game::get_InSkippableCutscene", (void*)Game_GetInSkippableCutscene);
ccAddExternalFunctionForPlugin("Game::get_InventoryItemCount", (void*)Game_GetInventoryItemCount);
ccAddExternalFunctionForPlugin("Game::get_MinimumTextDisplayTimeMs", (void*)Game_GetMinimumTextDisplayTimeMs);
ccAddExternalFunctionForPlugin("Game::set_MinimumTextDisplayTimeMs", (void*)Game_SetMinimumTextDisplayTimeMs);
ccAddExternalFunctionForPlugin("Game::get_MouseCursorCount", (void*)Game_GetMouseCursorCount);
ccAddExternalFunctionForPlugin("Game::get_Name", (void*)Game_GetName);
ccAddExternalFunctionForPlugin("Game::set_Name", (void*)Game_SetName);
ccAddExternalFunctionForPlugin("Game::get_NormalFont", (void*)Game_GetNormalFont);
ccAddExternalFunctionForPlugin("Game::set_NormalFont", (void*)SetNormalFont);
ccAddExternalFunctionForPlugin("Game::get_SkippingCutscene", (void*)Game_GetSkippingCutscene);
ccAddExternalFunctionForPlugin("Game::get_SpeechFont", (void*)Game_GetSpeechFont);
ccAddExternalFunctionForPlugin("Game::set_SpeechFont", (void*)SetSpeechFont);
ccAddExternalFunctionForPlugin("Game::geti_SpriteWidth", (void*)Game_GetSpriteWidth);
ccAddExternalFunctionForPlugin("Game::geti_SpriteHeight", (void*)Game_GetSpriteHeight);
ccAddExternalFunctionForPlugin("Game::get_TextReadingSpeed", (void*)Game_GetTextReadingSpeed);
ccAddExternalFunctionForPlugin("Game::set_TextReadingSpeed", (void*)Game_SetTextReadingSpeed);
ccAddExternalFunctionForPlugin("Game::get_TranslationFilename", (void*)Game_GetTranslationFilename);
ccAddExternalFunctionForPlugin("Game::get_ViewCount", (void*)Game_GetViewCount);
}
void RegisterStaticObjects()
{
ccAddExternalStaticObject("game",&play, &GameStaticManager);
ccAddExternalStaticObject("mouse",&scmouse, &scmouse);
ccAddExternalStaticObject("palette",&palette[0], &GlobalStaticManager); // TODO: proper manager
ccAddExternalStaticObject("system",&scsystem, &scsystem);
// [OBSOLETE] legacy arrays
ccAddExternalStaticObject("gs_globals", &play.globalvars[0], &GlobalStaticManager);
ccAddExternalStaticObject("savegameindex",&play.filenumbers[0], &GlobalStaticManager);
}
| 32.386555 | 198 | 0.66684 | SpeechCenter |
4b35a1305f82161d1039c565fa52105daaedd6b0 | 1,003 | cpp | C++ | ABC154/ABC154D.cpp | KoukiNAGATA/c- | ae51bacb9facb936a151dd777beb6688383a2dcd | [
"MIT"
] | null | null | null | ABC154/ABC154D.cpp | KoukiNAGATA/c- | ae51bacb9facb936a151dd777beb6688383a2dcd | [
"MIT"
] | 3 | 2021-03-31T01:39:25.000Z | 2021-05-04T10:02:35.000Z | ABC154/ABC154D.cpp | KoukiNAGATA/c- | ae51bacb9facb936a151dd777beb6688383a2dcd | [
"MIT"
] | null | null | null | #include <iostream>
#include <vector>
#include <cstdio>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
int n, k;
cin >> n >> k;
vector<float> v(n + k + 10, 0.0);
vector<float> s(n + k + 10, 0.0);
vector<float> dp(n + k + 10, 0.0);
float tmp;
for (int i = 1; i <= n; i++)
{ //1オリジン
cin >> tmp;
v[i] = (1.0 + tmp) / 2.0;
}
//初期化
v[0] = 0.0;
if (k > 1)
{
for (int i = 1; i < k; i++)
{ //0番目からk-1番目までの和
s[0] += v[i];
}
}
else
{
s[0] = 0.0;
}
dp[0] = s[0];
for (int i = 1; i <= n; i++)
{ //余分に回して0を入れる
s[i] = s[i - 1] - v[i - 1] + v[i + k - 1]; //n+10の範囲を超えてる可能性があるので余裕もって配列を作る
if (s[i] > dp[i - 1])
{ //最大値を更新
dp[i] = s[i];
}
else
{ //更新しなかった
dp[i] = dp[i - 1];
}
}
cout << dp[n] << "\n";
return 0;
} | 19.288462 | 83 | 0.363908 | KoukiNAGATA |
4b372c7f74d23b4c806a9cba4e5b1a3f75f1dbfd | 5,880 | cpp | C++ | src/cpotrf_mgpu.cpp | shengren/magma-1.6.1 | 1adfee30b763e9491a869403e0f320b3888923b6 | [
"BSD-3-Clause"
] | 21 | 2017-10-06T05:05:05.000Z | 2022-03-13T15:39:20.000Z | src/cpotrf_mgpu.cpp | shengren/magma-1.6.1 | 1adfee30b763e9491a869403e0f320b3888923b6 | [
"BSD-3-Clause"
] | 1 | 2017-03-23T00:27:24.000Z | 2017-03-23T00:27:24.000Z | src/cpotrf_mgpu.cpp | shengren/magma-1.6.1 | 1adfee30b763e9491a869403e0f320b3888923b6 | [
"BSD-3-Clause"
] | 4 | 2018-01-09T15:49:58.000Z | 2022-03-13T15:39:27.000Z | /*
-- MAGMA (version 1.6.1) --
Univ. of Tennessee, Knoxville
Univ. of California, Berkeley
Univ. of Colorado, Denver
@date January 2015
@generated from zpotrf_mgpu.cpp normal z -> c, Fri Jan 30 19:00:13 2015
*/
#include "common_magma.h"
/**
Purpose
-------
CPOTRF computes the Cholesky factorization of a complex Hermitian
positive definite matrix dA.
The factorization has the form
dA = U**H * U, if UPLO = MagmaUpper, or
dA = L * L**H, if UPLO = MagmaLower,
where U is an upper triangular matrix and L is lower triangular.
This is the block version of the algorithm, calling Level 3 BLAS.
Arguments
---------
@param[in]
ngpu INTEGER
Number of GPUs to use. ngpu > 0.
@param[in]
uplo magma_uplo_t
- = MagmaUpper: Upper triangle of dA is stored;
- = MagmaLower: Lower triangle of dA is stored.
@param[in]
n INTEGER
The order of the matrix dA. N >= 0.
@param[in,out]
d_lA COMPLEX array of pointers on the GPU, dimension (ngpu)
On entry, the Hermitian matrix dA distributed over GPUs
(d_lA[d] points to the local matrix on the d-th GPU).
It is distributed in 1D block column or row cyclic (with the
block size of nb) if UPLO = MagmaUpper or MagmaLower, respectively.
If UPLO = MagmaUpper, the leading N-by-N upper triangular
part of dA contains the upper triangular part of the matrix dA,
and the strictly lower triangular part of dA is not referenced.
If UPLO = MagmaLower, the leading N-by-N lower triangular part
of dA contains the lower triangular part of the matrix dA, and
the strictly upper triangular part of dA is not referenced.
\n
On exit, if INFO = 0, the factor U or L from the Cholesky
factorization dA = U**H * U or dA = L * L**H.
@param[in]
ldda INTEGER
The leading dimension of the array d_lA. LDDA >= max(1,N).
To benefit from coalescent memory accesses LDDA must be
divisible by 16.
@param[out]
info INTEGER
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value
- > 0: if INFO = i, the leading minor of order i is not
positive definite, and the factorization could not be
completed.
@ingroup magma_cposv_comp
********************************************************************/
extern "C" magma_int_t
magma_cpotrf_mgpu(
magma_int_t ngpu,
magma_uplo_t uplo, magma_int_t n,
magmaFloatComplex_ptr d_lA[], magma_int_t ldda,
magma_int_t *info)
{
magma_int_t j, nb, d, lddp, h;
const char* uplo_ = lapack_uplo_const( uplo );
magmaFloatComplex *work;
int upper = (uplo == MagmaUpper);
magmaFloatComplex *dwork[MagmaMaxGPUs];
magma_queue_t stream[MagmaMaxGPUs][3];
magma_event_t event[MagmaMaxGPUs][5];
*info = 0;
nb = magma_get_cpotrf_nb(n);
if (! upper && uplo != MagmaLower) {
*info = -1;
} else if (n < 0) {
*info = -2;
} else if (!upper) {
lddp = nb*(n/(nb*ngpu));
if ( n%(nb*ngpu) != 0 ) lddp += min(nb, n-ngpu*lddp);
if ( ldda < lddp ) *info = -4;
} else if ( ldda < n ) {
*info = -4;
}
if (*info != 0) {
magma_xerbla( __func__, -(*info) );
return *info;
}
magma_device_t orig_dev;
magma_getdevice( &orig_dev );
if (ngpu == 1 && ((nb <= 1) || (nb >= n)) ) {
/* Use unblocked code. */
magma_setdevice(0);
if (MAGMA_SUCCESS != magma_cmalloc_pinned( &work, n*nb )) {
*info = MAGMA_ERR_HOST_ALLOC;
return *info;
}
magma_cgetmatrix( n, n, d_lA[0], ldda, work, n );
lapackf77_cpotrf(uplo_, &n, work, &n, info);
magma_csetmatrix( n, n, work, n, d_lA[0], ldda );
magma_free_pinned( work );
}
else {
lddp = nb*((n+nb-1)/nb);
for( d=0; d < ngpu; d++ ) {
magma_setdevice(d);
if (MAGMA_SUCCESS != magma_cmalloc( &dwork[d], ngpu*nb*lddp )) {
for( j=0; j < d; j++ ) {
magma_setdevice(j);
magma_free( dwork[j] );
}
*info = MAGMA_ERR_DEVICE_ALLOC;
return *info;
}
for( j=0; j < 3; j++ )
magma_queue_create( &stream[d][j] );
for( j=0; j < 5; j++ )
magma_event_create( &event[d][j] );
}
magma_setdevice(0);
h = 1; //ngpu; //(n+nb-1)/nb;
if (MAGMA_SUCCESS != magma_cmalloc_pinned( &work, n*nb*h )) {
*info = MAGMA_ERR_HOST_ALLOC;
return *info;
}
if (upper) {
/* with three streams */
magma_cpotrf3_mgpu(ngpu, uplo, n, n, 0, 0, nb, d_lA, ldda, dwork, lddp, work, n,
h, stream, event, info);
} else {
/* with three streams */
magma_cpotrf3_mgpu(ngpu, uplo, n, n, 0, 0, nb, d_lA, ldda, dwork, lddp, work, nb*h,
h, stream, event, info);
}
/* clean up */
for( d=0; d < ngpu; d++ ) {
magma_setdevice(d);
for( j=0; j < 3; j++ ) {
magma_queue_sync( stream[d][j] );
magma_queue_destroy( stream[d][j] );
}
for( j=0; j < 5; j++ )
magma_event_destroy( event[d][j] );
magma_free( dwork[d] );
}
magma_free_pinned( work );
} /* end of not lapack */
magma_setdevice( orig_dev );
return *info;
} /* magma_cpotrf_mgpu */
| 33.6 | 95 | 0.522449 | shengren |
4b37f86dbc4fdd78055aadd3ce416277edd8b2a9 | 10,031 | cpp | C++ | game_shared/voice_status.cpp | darealshinji/halflife | f3853c2a666c3264d218cf2d1b14b17c0b21c073 | [
"Unlicense"
] | 1 | 2020-07-14T12:47:38.000Z | 2020-07-14T12:47:38.000Z | game_shared/voice_status.cpp | darealshinji/hlspbunny-v4 | f3853c2a666c3264d218cf2d1b14b17c0b21c073 | [
"Unlicense"
] | null | null | null | game_shared/voice_status.cpp | darealshinji/hlspbunny-v4 | f3853c2a666c3264d218cf2d1b14b17c0b21c073 | [
"Unlicense"
] | null | null | null |
#include <stdio.h>
#include <string.h>
#include "wrect.h"
#include "cl_dll.h"
#include "cl_util.h"
#include "cl_entity.h"
#include "const.h"
#include "parsemsg.h" // BEGIN_READ(), ...
#include "voice_status.h"
static CVoiceStatus *g_pInternalVoiceStatus = NULL;
// ---------------------------------------------------------------------- //
// The voice manager for the client.
// ---------------------------------------------------------------------- //
CVoiceStatus g_VoiceStatus;
CVoiceStatus* GetClientVoice()
{
return &g_VoiceStatus;
}
int __MsgFunc_VoiceMask(const char *pszName, int iSize, void *pbuf)
{
if(g_pInternalVoiceStatus)
g_pInternalVoiceStatus->HandleVoiceMaskMsg(iSize, pbuf);
return 1;
}
int __MsgFunc_ReqState(const char *pszName, int iSize, void *pbuf)
{
if(g_pInternalVoiceStatus)
g_pInternalVoiceStatus->HandleReqStateMsg(iSize, pbuf);
return 1;
}
int g_BannedPlayerPrintCount;
void ForEachBannedPlayer(char id[16])
{
char str[256];
sprintf(str, "Ban %d: %2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x\n",
g_BannedPlayerPrintCount++,
id[0], id[1], id[2], id[3],
id[4], id[5], id[6], id[7],
id[8], id[9], id[10], id[11],
id[12], id[13], id[14], id[15]
);
#ifdef _WIN32
strupr(str);
#endif
gEngfuncs.pfnConsolePrint(str);
}
void ShowBannedCallback()
{
if(g_pInternalVoiceStatus)
{
g_BannedPlayerPrintCount = 0;
gEngfuncs.pfnConsolePrint("------- BANNED PLAYERS -------\n");
g_pInternalVoiceStatus->GetBanMgr()->ForEachBannedPlayer(ForEachBannedPlayer);
gEngfuncs.pfnConsolePrint("------------------------------\n");
}
}
CVoiceStatus::CVoiceStatus()
{
m_bBanMgrInitialized = false;
m_LastUpdateServerState = 0;
m_bTalking = m_bServerAcked = false;
m_bServerModEnable = -1;
m_pchGameDir = NULL;
}
CVoiceStatus::~CVoiceStatus()
{
g_pInternalVoiceStatus = NULL;
if(m_pchGameDir)
{
if(m_bBanMgrInitialized)
{
m_BanMgr.SaveState(m_pchGameDir);
}
free(m_pchGameDir);
}
}
void CVoiceStatus::Init( IVoiceStatusHelper *pHelper)
{
// Setup the voice_modenable cvar.
gEngfuncs.pfnRegisterVariable("voice_modenable", "1", FCVAR_ARCHIVE);
gEngfuncs.pfnRegisterVariable("voice_clientdebug", "0", 0);
gEngfuncs.pfnAddCommand("voice_showbanned", ShowBannedCallback);
// Cache the game directory for use when we shut down
const char *pchGameDirT = gEngfuncs.pfnGetGameDirectory();
m_pchGameDir = (char *)malloc(strlen(pchGameDirT) + 1);
if(m_pchGameDir)
{
strcpy(m_pchGameDir, pchGameDirT);
}
if(m_pchGameDir)
{
m_BanMgr.Init(m_pchGameDir);
m_bBanMgrInitialized = true;
}
assert(!g_pInternalVoiceStatus);
g_pInternalVoiceStatus = this;
m_bInSquelchMode = false;
m_pHelper = pHelper;
HOOK_MESSAGE(VoiceMask);
HOOK_MESSAGE(ReqState);
GetClientVoiceHud()->Init(pHelper,this);
}
void CVoiceStatus::Frame(double frametime)
{
// check server banned players once per second
if(gEngfuncs.GetClientTime() - m_LastUpdateServerState > 1)
{
UpdateServerState(false);
}
}
void CVoiceStatus::StartSquelchMode()
{
if(m_bInSquelchMode)
return;
m_bInSquelchMode = true;
}
void CVoiceStatus::StopSquelchMode()
{
m_bInSquelchMode = false;
}
bool CVoiceStatus::IsInSquelchMode()
{
return m_bInSquelchMode;
}
void CVoiceStatus::UpdateServerState(bool bForce)
{
// Can't do anything when we're not in a level.
char const *pLevelName = gEngfuncs.pfnGetLevelName();
if( pLevelName[0] == 0 )
{
if( gEngfuncs.pfnGetCvarFloat("voice_clientdebug") )
{
gEngfuncs.pfnConsolePrint( "CVoiceStatus::UpdateServerState: pLevelName[0]==0\n" );
}
return;
}
int bCVarModEnable = !!gEngfuncs.pfnGetCvarFloat("voice_modenable");
if(bForce || m_bServerModEnable != bCVarModEnable)
{
m_bServerModEnable = bCVarModEnable;
char str[256];
_snprintf(str, sizeof(str), "VModEnable %d", m_bServerModEnable);
ServerCmd(str);
if(gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
{
char msg[256];
sprintf(msg, "CVoiceStatus::UpdateServerState: Sending '%s'\n", str);
gEngfuncs.pfnConsolePrint(msg);
}
}
char str[2048];
sprintf(str, "vban");
bool bChange = false;
for(uint32 dw=0; dw < VOICE_MAX_PLAYERS_DW; dw++)
{
uint32 serverBanMask = 0;
uint32 banMask = 0;
for(uint32 i=0; i < 32; i++)
{
char playerID[16];
if(!gEngfuncs.GetPlayerUniqueID(i+1, playerID))
continue;
if(m_BanMgr.GetPlayerBan(playerID))
banMask |= 1 << i;
if(m_ServerBannedPlayers[dw*32 + i])
serverBanMask |= 1 << i;
}
if(serverBanMask != banMask)
bChange = true;
// Ok, the server needs to be updated.
char numStr[512];
sprintf(numStr, " %x", banMask);
strcat(str, numStr);
}
if(bChange || bForce)
{
if(gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
{
char msg[256];
sprintf(msg, "CVoiceStatus::UpdateServerState: Sending '%s'\n", str);
gEngfuncs.pfnConsolePrint(msg);
}
gEngfuncs.pfnServerCmdUnreliable(str); // Tell the server..
}
else
{
if (gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
{
gEngfuncs.pfnConsolePrint( "CVoiceStatus::UpdateServerState: no change\n" );
}
}
m_LastUpdateServerState = gEngfuncs.GetClientTime();
}
int CVoiceStatus::GetSpeakerStatus(int iPlayer)
{
bool bTalking = static_cast<bool>(m_VoicePlayers[iPlayer]);
char playerID[16];
qboolean id = gEngfuncs.GetPlayerUniqueID( iPlayer+1, playerID );
if(!id)
return VOICE_NEVERSPOKEN;
bool bBanned = m_BanMgr.GetPlayerBan( playerID );
bool bNeverSpoken = !m_VoiceEnabledPlayers[iPlayer];
if(bBanned)
{
return VOICE_BANNED;
}
else if(bNeverSpoken)
{
return VOICE_NEVERSPOKEN;
}
else if(bTalking)
{
return VOICE_TALKING;
}
else
return VOICE_NOTTALKING;
}
void CVoiceStatus::HandleVoiceMaskMsg(int iSize, void *pbuf)
{
BEGIN_READ( pbuf, iSize );
uint32 dw;
for(dw=0; dw < VOICE_MAX_PLAYERS_DW; dw++)
{
m_AudiblePlayers.SetDWord(dw, (uint32)READ_LONG());
m_ServerBannedPlayers.SetDWord(dw, (uint32)READ_LONG());
if(gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
{
char str[256];
gEngfuncs.pfnConsolePrint("CVoiceStatus::HandleVoiceMaskMsg\n");
sprintf(str, " - m_AudiblePlayers[%d] = %lu\n", dw, m_AudiblePlayers.GetDWord(dw));
gEngfuncs.pfnConsolePrint(str);
sprintf(str, " - m_ServerBannedPlayers[%d] = %lu\n", dw, m_ServerBannedPlayers.GetDWord(dw));
gEngfuncs.pfnConsolePrint(str);
}
}
m_bServerModEnable = READ_BYTE();
}
void CVoiceStatus::HandleReqStateMsg(int iSize, void *pbuf)
{
if(gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
{
gEngfuncs.pfnConsolePrint("CVoiceStatus::HandleReqStateMsg\n");
}
UpdateServerState(true);
}
void CVoiceStatus::UpdateSpeakerStatus(int entindex, bool bTalking)
{
const char *levelName = gEngfuncs.pfnGetLevelName();
if (levelName && levelName[0])
{
if( gEngfuncs.pfnGetCvarFloat("voice_clientdebug") )
{
char msg[256];
_snprintf( msg, sizeof(msg), "CVoiceStatus::UpdateSpeakerStatus: ent %d talking = %d\n", entindex, bTalking );
gEngfuncs.pfnConsolePrint( msg );
}
// Is it the local player talking?
if( entindex == -1 )
{
m_bTalking = bTalking;
if( bTalking )
{
// Enable voice for them automatically if they try to talk.
gEngfuncs.pfnClientCmd( "voice_modenable 1" );
}
if ( !gEngfuncs.GetLocalPlayer() )
{
return;
}
int entindex = gEngfuncs.GetLocalPlayer()->index;
GetClientVoiceHud()->UpdateSpeakerStatus(-2,bTalking);
m_VoicePlayers[entindex-1] = m_bTalking;
m_VoiceEnabledPlayers[entindex-1]= true;
}
else if( entindex == -2 )
{
m_bServerAcked = bTalking;
}
else if(entindex >= 0 && entindex <= VOICE_MAX_PLAYERS)
{
int iClient = entindex - 1;
if(iClient < 0)
return;
GetClientVoiceHud()->UpdateSpeakerStatus(entindex,bTalking);
if(bTalking)
{
m_VoicePlayers[iClient] = true;
m_VoiceEnabledPlayers[iClient] = true;
}
else
{
m_VoicePlayers[iClient] = false;
}
}
GetClientVoiceHud()->RepositionLabels();
}
}
//-----------------------------------------------------------------------------
// Purpose: returns true if the target client has been banned
// Input : playerID -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CVoiceStatus::IsPlayerBlocked(int iPlayer)
{
char playerID[16];
if (!gEngfuncs.GetPlayerUniqueID(iPlayer, playerID))
return false;
return m_BanMgr.GetPlayerBan(playerID);
}
//-----------------------------------------------------------------------------
// Purpose: returns true if the player can't hear the other client due to game rules (eg. the other team)
// Input : playerID -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CVoiceStatus::IsPlayerAudible(int iPlayer)
{
return !!m_AudiblePlayers[iPlayer-1];
}
//-----------------------------------------------------------------------------
// Purpose: blocks/unblocks the target client from being heard
// Input : playerID -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CVoiceStatus::SetPlayerBlockedState(int iPlayer, bool blocked)
{
if (gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
{
gEngfuncs.pfnConsolePrint( "CVoiceStatus::SetPlayerBlockedState part 1\n" );
}
char playerID[16];
if (!gEngfuncs.GetPlayerUniqueID(iPlayer, playerID))
return;
if (gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
{
gEngfuncs.pfnConsolePrint( "CVoiceStatus::SetPlayerBlockedState part 2\n" );
}
// Squelch or (try to) unsquelch this player.
if (gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
{
char str[256];
sprintf(str, "CVoiceStatus::SetPlayerBlockedState: setting player %d ban to %d\n", iPlayer, !m_BanMgr.GetPlayerBan(playerID));
gEngfuncs.pfnConsolePrint(str);
}
m_BanMgr.SetPlayerBan( playerID, blocked );
UpdateServerState(false);
}
| 21.525751 | 128 | 0.662945 | darealshinji |
4b3e15649008fff3ff878c272fb4d0dc5fe8314f | 1,134 | cpp | C++ | heap_sort.cpp | MDarshan123/Algorithms-1 | c077ef399f4fea59f683c0338e56d1a87a79a466 | [
"MIT"
] | 33 | 2019-10-20T03:07:31.000Z | 2021-12-05T06:50:12.000Z | heap_sort.cpp | MDarshan123/Algorithms-1 | c077ef399f4fea59f683c0338e56d1a87a79a466 | [
"MIT"
] | 51 | 2019-10-09T18:09:53.000Z | 2021-07-06T08:28:39.000Z | heap_sort.cpp | MDarshan123/Algorithms-1 | c077ef399f4fea59f683c0338e56d1a87a79a466 | [
"MIT"
] | 117 | 2019-10-09T18:10:58.000Z | 2022-02-22T14:22:47.000Z | # Python program for implementation of heap Sort
# To heapify subtree rooted at index i.
# n is size of heap
def heapify(arr, n, i):
largest = i # Initialize largest as root
l = 2 * i + 1 # left = 2*i + 1
r = 2 * i + 2 # right = 2*i + 2
# See if left child of root exists and is
# greater than root
if l < n and arr[i] < arr[l]:
largest = l
# See if right child of root exists and is
# greater than root
if r < n and arr[largest] < arr[r]:
largest = r
# Change root, if needed
if largest != i:
arr[i],arr[largest] = arr[largest],arr[i] # swap
# Heapify the root.
heapify(arr, n, largest)
# The main function to sort an array of given size
def heapSort(arr):
n = len(arr)
# Build a maxheap.
for i in range(n//2 - 1, -1, -1):
heapify(arr, n, i)
# One by one extract elements
for i in range(n-1, 0, -1):
arr[i], arr[0] = arr[0], arr[i] # swap
heapify(arr, i, 0)
# Driver code to test above
arr = [ 12, 11, 13, 5, 6, 7]
heapSort(arr)
n = len(arr)
print ("Sorted array is")
for i in range(n):
print ("%d" %arr[i]),
# This code is contributed by Mohit Kumra
| 23.625 | 51 | 0.603175 | MDarshan123 |
4b42a06a27f4d72f91b1a18e9c18eb11801c3a31 | 24,236 | cpp | C++ | tests/args-test.cpp | mbits-libs/libargs | 72f5f2b87ae39f26638a585fa4ad0b96b4152ae6 | [
"MIT"
] | null | null | null | tests/args-test.cpp | mbits-libs/libargs | 72f5f2b87ae39f26638a585fa4ad0b96b4152ae6 | [
"MIT"
] | 2 | 2020-09-25T10:07:38.000Z | 2020-10-11T16:01:17.000Z | tests/args-test.cpp | mbits-libs/libargs | 72f5f2b87ae39f26638a585fa4ad0b96b4152ae6 | [
"MIT"
] | null | null | null | #include <args/parser.hpp>
#include <iostream>
#include <string_view>
using namespace std::literals;
struct test {
const char* title;
int (*callback)();
int expected{0};
std::string_view output{};
};
std::vector<test> g_tests;
template <typename Test>
struct registrar {
registrar() {
::g_tests.push_back(
{Test::get_name(), Test::run, Test::expected(), Test::output()});
}
};
#define TEST_BASE(name, EXPECTED, OUTPUT) \
struct test_##name { \
static const char* get_name() noexcept { return #name; } \
static int run(); \
static int expected() noexcept { return (EXPECTED); } \
static std::string_view output() noexcept { return OUTPUT; } \
}; \
registrar<test_##name> reg_##name; \
int test_##name ::run()
#define TEST(name) TEST_BASE(name, 0, {})
#define TEST_FAIL(name) TEST_BASE(name, 1, {})
#define TEST_OUT(name, OUTPUT) TEST_BASE(name, 0, OUTPUT)
#define TEST_FAIL_OUT(name, OUTPUT) TEST_BASE(name, 1, OUTPUT)
int main(int argc, char* argv[]) {
if (argc == 1) {
for (auto const& test : g_tests) {
printf("%d:%s:", test.expected, test.title);
if (!test.output.empty())
printf("%.*s", static_cast<int>(test.output.size()),
test.output.data());
putc('\n', stdout);
}
return 0;
}
auto const int_test = atoi(argv[1]);
if (int_test < 0) return 100;
auto const test = static_cast<size_t>(int_test);
return g_tests[test].callback();
}
template <typename... CString, typename Mod>
int every_test_ever(Mod mod, CString... args) {
std::string arg_opt;
std::string arg_req;
bool starts_as_false{false};
bool starts_as_true{true};
std::vector<std::string> multi_opt;
std::vector<std::string> multi_req;
std::string positional;
char arg0[] = "args-help-test";
char* __args[] = {arg0, (const_cast<char*>(args))..., nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.arg(arg_opt, "o", "opt").meta("VAR").help("a help for arg_opt").opt();
p.arg(arg_req, "r", "req").help("a help for arg_req");
p.set<std::true_type>(starts_as_false, "on", "1")
.help("a help for on")
.opt();
p.set<std::false_type>(starts_as_true, "off", "0")
.help("a help for off")
.opt();
p.arg(multi_opt, "first").help("zero or more").opt();
p.arg(multi_req, "second").meta("VAL").help("one or more");
p.arg(positional).meta("INPUT").help("a help for positional").opt();
mod(p);
p.parse();
return 0;
}
void noop(const args::parser&) {}
void modify(args::parser& parser) {
parser.program("another");
if (parser.program() != "another") {
fprintf(stderr, "Program not changed: %s\n", parser.program().c_str());
std::exit(1);
}
parser.usage("[OPTIONS]");
if (parser.usage() != "[OPTIONS]") {
fprintf(stderr, "Usage not changed: %s\n", parser.usage().c_str());
std::exit(1);
}
}
void enable_answers(args::parser& parser) {
parser.use_answer_file();
}
void enable_answers_dollar(args::parser& parser) {
parser.use_answer_file('$');
}
template <typename T, typename U>
void EQ_impl(T&& lhs, U&& rhs, const char* lhs_name, const char* rhs_name) {
if (lhs == rhs) return;
std::cerr << "Expected equality of these values:\n " << std::boolalpha
<< lhs_name << "\n Which is: " << lhs << "\n " << rhs_name
<< "\n Which is: " << rhs << "\n";
std::exit(1);
}
#define EQ(lhs, rhs) EQ_impl(lhs, rhs, #lhs, #rhs)
TEST(gen_usage) {
return every_test_ever(
[](args::parser& parser) {
std::string shrt;
const std::string_view expected_help =
"args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first "
"ARG "
"...] --second VAL [--second VAL ...] [INPUT]";
parser.printer_append_usage(shrt);
EQ(expected_help, shrt);
},
"-r", "x", "--second", "somsink");
}
TEST(gen_usage_no_help) {
return every_test_ever(
[](args::parser& parser) {
std::string shrt;
const std::string_view expected_no_help =
"args-help-test [-o VAR] -r ARG [--on] [--off] [--first ARG "
"...] "
"--second VAL [--second VAL ...] [INPUT]";
parser.provide_help(false);
parser.printer_append_usage(shrt);
EQ(expected_no_help, shrt);
},
"-r", "x", "--second", "somsink");
}
TEST_OUT(
short_help_argument,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\n\nprogram description\n\npositional arguments:\n INPUT a help for positional\n\noptional arguments:\n -h, --help show this help message and exit\n -o, --opt VAR a help for arg_opt\n -r, --req ARG a help for arg_req\n --on, -1 a help for on\n --off, -0 a help for off\n --first ARG zero or more\n --second VAL one or more\n)"sv) {
return every_test_ever(noop, "-h");
}
TEST_OUT(
long_help_argument,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\n\nprogram description\n\npositional arguments:\n INPUT a help for positional\n\noptional arguments:\n -h, --help show this help message and exit\n -o, --opt VAR a help for arg_opt\n -r, --req ARG a help for arg_req\n --on, -1 a help for on\n --off, -0 a help for off\n --first ARG zero or more\n --second VAL one or more\n)"sv) {
return every_test_ever(noop, "--help");
}
TEST(help_mod) {
return every_test_ever(modify, "-h");
}
TEST_FAIL_OUT(
no_req,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\nargs-help-test: error: argument -r is required\n)"sv) {
return every_test_ever(noop);
}
TEST_FAIL(no_req_mod) {
return every_test_ever(modify);
}
// TODO: used to be test_fail; regeresion or code behind fixed?
TEST(full) {
return every_test_ever(noop, "-oVALUE", "-r", "SEPARATE", "--req",
"ANOTHER ONE", "--on", "-10", "--off", "--second",
"somsink", "POSITIONAL");
}
TEST_FAIL_OUT(
missing_arg_short,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\nargs-help-test: error: argument -r: expected one argument\n)"sv) {
return every_test_ever(noop, "-r");
}
TEST_FAIL_OUT(
missing_arg,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\nargs-help-test: error: argument --req: expected one argument\n)"sv) {
return every_test_ever(noop, "--req");
}
TEST_FAIL_OUT(
missing_positional,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT] POSITIONAL [POSITIONAL ...]\nargs-help-test: error: argument POSITIONAL is required\n)"sv) {
std::vector<std::string> one_plus;
return every_test_ever(
[&](args::parser& p) {
p.arg(one_plus)
.meta("POSITIONAL")
.help("this parameter must be given at least once");
},
"-r", "x", "--second", "somsink");
}
TEST_FAIL_OUT(
unknown,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\nargs-help-test: error: unrecognized argument: --flag\n)"sv) {
return every_test_ever(noop, "--flag");
}
TEST_FAIL_OUT(
unknown_short,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\nargs-help-test: error: unrecognized argument: -f\n)"sv) {
return every_test_ever(noop, "-f");
}
TEST_FAIL_OUT(
unknown_positional,
R"(usage: args-help-test [-h]\nargs-help-test: error: unrecognized argument: POSITIONAL\n)"sv) {
#ifdef _WIN32
char arg0[] = R"(C:\Program Files\Program Name\args-help-test.exe)";
#else
char arg0[] = "/usr/bin/args-help-test";
#endif
char arg1[] = "POSITIONAL";
char* __args[] = {arg0, arg1, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.parse();
return 0;
}
TEST(console_width) {
const auto isatty = args::detail::is_terminal(stdout);
const auto width = args::detail::terminal_width(stdout);
return isatty ? (width ? 0 : 1) : (width ? 1 : 0);
}
TEST_OUT(
width_forced,
R"(usage: args-help-test [-h] [INPUT]\n\nThis is a very long description of the\nprogram, which should span multiple\nlines in narrow consoles. This will be\ntested with forcing a console width in\nthe parse() method.\n\npositional arguments:\n INPUT This is a very long\n description of the INPUT\n param, which should span\n multiple lines in narrow\n consoles. This will be\n tested with forcing a\n console width in the\n parse() method. Also,\n here's a long word:\n supercalifragilisticexpiali\n docious\n\noptional arguments:\n -h, --help show this help message and\n exit\n)"sv) {
std::string positional;
char arg0[] = "args-help-test";
char arg1[] = "-h";
char* __args[] = {arg0, arg1, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
auto prog_descr =
"This is a very long description of the program, "
"which should span multiple lines in narrow consoles. "
"This will be tested with forcing a console width in "
"the parse() method."s;
auto long_descr =
"This is a very long description of the INPUT param, "
"which should span multiple lines in narrow consoles. "
"This will be tested with forcing a console width in "
"the parse() method. Also, here's a long word: "
"supercalifragilisticexpialidocious"s;
::args::null_translator tr;
::args::parser p{std::move(prog_descr), ::args::from_main(argc, __args),
&tr};
p.arg(positional).meta("INPUT").help(std::move(long_descr)).opt();
p.parse(::args::parser::exclusive_parser, 40);
return 0;
}
TEST_FAIL(not_an_int) {
int value;
char arg0[] = "args-help-test";
char arg1[] = "--num";
char arg2[] = "value";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.arg(value, "num").meta("NUMBER").opt();
p.parse();
return 0;
}
TEST_FAIL(out_of_range) {
int value;
char arg0[] = "args-help-test";
char arg1[] = "--num";
char arg2[] =
"123456789012345678901234567890123456789012345678901234567890";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.arg(value, "num").meta("NUMBER").opt();
p.parse();
return 0;
}
TEST(optional_int_1) {
std::optional<int> value;
char arg0[] = "args-help-test";
char arg1[] = "--num";
char arg2[] = "12345";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.arg(value, "num").meta("NUMBER");
p.parse();
constexpr auto has_value = true;
constexpr auto the_value = 12345;
EQ(has_value, !!value);
EQ(the_value, *value);
return 0;
}
TEST(optional_int_2) {
std::optional<int> value;
char arg0[] = "args-help-test";
char* __args[] = {arg0, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.arg(value, "num").meta("NUMBER");
p.parse();
constexpr auto no_value = false;
EQ(no_value, !!value);
return 0;
}
TEST(subcmd_long) {
char arg0[] = "args-help-test";
char arg1[] = "--num";
char arg2[] = "12345";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.parse(::args::parser::allow_subcommands);
return 0;
}
TEST(subcmd_short) {
char arg0[] = "args-help-test";
char arg1[] = "-n";
char arg2[] = "12345";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.parse(::args::parser::allow_subcommands);
return 0;
}
TEST(subcmd_positional) {
char arg0[] = "args-help-test";
char arg1[] = "a_path";
char arg2[] = "12345";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.parse(::args::parser::allow_subcommands);
return 0;
}
TEST(custom_simple_1) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char* __args[] = {arg0, arg1, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.custom([] {}, "path");
p.parse();
return 0;
}
TEST(custom_simple_1_exit) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char* __args[] = {arg0, arg1, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.custom([] { std::exit(0); }, "path");
p.parse();
return 1;
}
TEST(custom_simple_2) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char* __args[] = {arg0, arg1, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.custom([](::args::parser&) {}, "path");
p.parse();
return 0;
}
TEST(custom_simple_2_exit) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char* __args[] = {arg0, arg1, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.custom([](::args::parser&) { std::exit(0); }, "path");
p.parse();
return 1;
}
TEST(custom_string_1) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char arg2[] = "value";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.custom([](std::string const&) {}, "path");
p.parse();
return 0;
}
TEST(custom_string_1_exit) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char arg2[] = "value";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.custom([=](std::string const& arg) { std::exit(arg != arg2); }, "path");
p.parse();
return 1;
}
TEST(custom_string_2) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char arg2[] = "value";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.custom([](::args::parser&, std::string const&) {}, "path");
p.parse();
return 0;
}
TEST(custom_string_2_exit) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char arg2[] = "value";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.custom([=](::args::parser&,
std::string const& arg) { std::exit(arg != arg2); },
"path");
p.parse();
return 1;
}
TEST(custom_string_view_1_exit) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char arg2[] = "value";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.custom([=](std::string_view arg) { std::exit(arg != arg2); }, "path");
p.parse();
return 1;
}
TEST(custom_string_view_2_exit) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char arg2[] = "value";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.custom(
[=](::args::parser&, std::string_view arg) { std::exit(arg != arg2); },
"path");
p.parse();
return 1;
}
TEST(empty_args) {
char* __args[] = {nullptr};
auto const args = ::args::from_main(0, __args);
constexpr auto expected_prog_name = ""sv;
constexpr auto expected_args = 0u;
EQ(expected_prog_name, args.progname);
EQ(expected_args, args.args.size());
return 0;
}
TEST(additional_ctors) {
char arg0[] = "args-help-test";
char arg1[] = "--path";
char arg2[] = "value";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
args::null_translator tr;
args::parser p1{""s, arg0, {argc - 1, __args + 1}, &tr};
args::parser p2{""s, args::arglist{argc, __args}, &tr};
return 0;
}
enum class thing { none, one, two };
ENUM_TRAITS_BEGIN(thing)
ENUM_TRAITS_NAME(one)
ENUM_TRAITS_NAME(two)
ENUM_TRAITS_END(thing)
TEST(enum_arg_one) {
char arg0[] = "args-help-test";
char arg1[] = "--thing";
char arg2[] = "one";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
thing which{thing::none};
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.arg(which, "thing");
p.parse();
return !(which == thing::one);
}
TEST(enum_arg_two) {
char arg0[] = "args-help-test";
char arg1[] = "--thing";
char arg2[] = "two";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
thing which{thing::none};
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.arg(which, "thing");
p.parse();
return !(which == thing::two);
}
TEST_FAIL_OUT(
enum_arg_three,
R"(usage: args-help-test [-h] --thing ARG\nargs-help-test: error: argument --thing: value three is not recognized\nknown values for --thing: one, two\n)"sv) {
char arg0[] = "args-help-test";
char arg1[] = "--thing";
char arg2[] = "three";
char* __args[] = {arg0, arg1, arg2, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
thing which{thing::none};
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.arg(which, "thing");
p.parse();
return !(which == thing::none);
}
TEST(long_param_eq) {
return every_test_ever(noop, "-r", "x", "--second=somsink");
}
TEST_FAIL_OUT(
long_param_eq_error,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\nargs-help-test: error: argument --off: value was not expected\n)"sv) {
return every_test_ever(noop, "-r", "x", "--second", "somsink", "--off=on");
}
TEST_OUT(utf_8,
"usage: args-help-test [-h] --\xC3\xA7-arg \xC3\xB1 --c-arg n\\n"
"\\n"
"program description\\n"
"\\n"
"optional arguments:\\n"
" -h, --help show this help message and exit\\n"
" --\xC3\xA7-arg \xC3\xB1 |<----\\n"
" --c-arg n |<----\\n"sv) {
char arg0[] = "args-help-test";
char arg1[] = "--help";
char* __args[] = {arg0, arg1, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
std::string argument{};
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.arg(argument, "\xC3\xA7-arg").meta("\xC3\xB1").help("|<----");
p.arg(argument, "c-arg").meta("n").help("|<----");
p.parse();
return 1;
}
TEST_FAIL_OUT(
no_answer_file_support,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...]\nargs-help-test: error: unrecognized argument: @minimal-args\n)"sv) {
std::string arg_opt;
std::string arg_req;
bool starts_as_false{false};
bool starts_as_true{true};
std::vector<std::string> multi_opt;
std::vector<std::string> multi_req;
char arg0[] = "args-help-test";
char arg1[] = "@minimal-args";
char* __args[] = {arg0, arg1, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.arg(arg_opt, "o", "opt").meta("VAR").help("a help for arg_opt").opt();
p.arg(arg_req, "r", "req").help("a help for arg_req");
p.set<std::true_type>(starts_as_false, "on", "1")
.help("a help for on")
.opt();
p.set<std::false_type>(starts_as_true, "off", "0")
.help("a help for off")
.opt();
p.arg(multi_opt, "first").help("zero or more").opt();
p.arg(multi_req, "second").meta("VAL").help("one or more");
p.parse();
return 0;
}
TEST(answer_file) {
return every_test_ever(enable_answers, "@minimal-args");
}
TEST_FAIL_OUT(
answer_file_not_found,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\nargs-help-test: error: cannot open no-such-file\n)"sv) {
return every_test_ever(enable_answers, "@no-such-file");
}
TEST(answer_file_before) {
char arg0[] = "args-help-test";
char arg1[] = "@minimal-args";
char arg2[] = "-r";
char arg3[] = "y";
char* __args[] = {arg0, arg1, arg2, arg3, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
std::string r{}, s{};
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.use_answer_file();
p.arg(r, "r", "req").help("a help for arg_req");
p.arg(s, "second").meta("VAL").help("one or more");
p.parse();
return !(r == "y");
}
TEST(answer_file_after) {
char arg0[] = "args-help-test";
char arg1[] = "-r";
char arg2[] = "y";
char arg3[] = "@minimal-args";
char* __args[] = {arg0, arg1, arg2, arg3, nullptr};
int argc = static_cast<int>(std::size(__args)) - 1;
std::string r{}, s{};
::args::null_translator tr;
::args::parser p{"program description", ::args::from_main(argc, __args),
&tr};
p.use_answer_file();
p.arg(r, "r", "req").help("a help for arg_req");
p.arg(s, "second").meta("VAL").help("one or more");
p.parse();
return !(r == "x");
}
TEST(answer_file_alt) {
return every_test_ever(enable_answers_dollar, "$minimal-args");
}
TEST_FAIL_OUT(
answer_file_unexpected,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\nargs-help-test: error: argument --off: value was not expected\n)"sv) {
return every_test_ever(enable_answers, "@unexpected-arg-value");
}
TEST_FAIL_OUT(
answer_file_unknown,
R"(usage: args-help-test [-h] [-o VAR] -r ARG [--on] [--off] [--first ARG ...] --second VAL [--second VAL ...] [INPUT]\nargs-help-test: error: unrecognized argument: --unexpected\n)"sv) {
return every_test_ever(enable_answers, "@unknown-arg");
}
| 31.151671 | 718 | 0.609589 | mbits-libs |
4b42cf206f3e1c9b44048a47981ebfdd2d78de10 | 6,505 | cpp | C++ | C++CodeSnippets/HLD [LOJ-1348].cpp | Maruf-Tuhin/Online_Judge | cf9b2a522e8b1a9623d3996a632caad7fd67f751 | [
"MIT"
] | 1 | 2019-03-31T05:47:30.000Z | 2019-03-31T05:47:30.000Z | C++CodeSnippets/HLD [LOJ-1348].cpp | the-redback/competitive-programming | cf9b2a522e8b1a9623d3996a632caad7fd67f751 | [
"MIT"
] | null | null | null | C++CodeSnippets/HLD [LOJ-1348].cpp | the-redback/competitive-programming | cf9b2a522e8b1a9623d3996a632caad7fd67f751 | [
"MIT"
] | null | null | null | /**
* @author : Maruf Tuhin
* @College : CUET CSE 11
* @Topcoder : the_redback
* @CodeForces : the_redback
* @UVA : the_redback
* @link : http://www.fb.com/maruf.2hin
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long llu;
#define ft first
#define sd second
#define mp make_pair
#define pb(x) push_back(x)
#define all(x) x.begin(), x.end()
#define allr(x) x.rbegin(), x.rend()
#define mem(a, b) memset(a, b, sizeof(a))
#define inf 1e9
#define eps 1e-9
#define mod 1000000007
#define NN 50010
#define read(a) scanf("%lld", &a)
#define root 0
#define LN 16
vector<ll> adj[NN];
ll baseArray[NN], ptr, value[NN];
ll chainNo, chainInd[NN], chainHead[NN], posInBase[NN];
ll depth[NN], par[NN][LN], subsize[NN];
ll seg[NN * 4];
void make_tree(ll node, ll low, ll high) {
if (low == high) {
seg[node] = baseArray[low];
return;
}
ll left = node << 1;
ll right = left | 1;
ll mid = (low + high) >> 1;
make_tree(left, low, mid);
make_tree(right, mid + 1, high);
seg[node] = seg[left] + seg[right];
return;
}
void update_tree(ll node, ll low, ll high, ll ind, ll val) {
if (low == ind && low == high) {
seg[node] = val;
return;
}
ll left = node << 1;
ll right = left | 1;
ll mid = (low + high) >> 1;
if (ind <= mid)
update_tree(left, low, mid, ind, val);
else
update_tree(right, mid + 1, high, ind, val);
seg[node] = seg[left] + seg[right];
return;
}
ll query_tree(ll node, ll low, ll high, ll rlow, ll rhigh) {
if (low >= rlow && high <= rhigh) {
return seg[node];
}
ll left = node << 1;
ll right = left | 1;
ll mid = (low + high) >> 1;
if (rhigh <= mid)
return query_tree(left, low, mid, rlow, rhigh);
else if (rlow > mid)
return query_tree(right, mid + 1, high, rlow, rhigh);
else {
ll L = query_tree(left, low, mid, rlow, mid);
ll R = query_tree(right, mid + 1, high, mid + 1, rhigh);
return L + R;
}
}
ll query_up(ll u, ll v) { // v is an ancestor of u
ll uchain, vchain = chainInd[v], ans = 0;
// uchain and vchain are chain numbers of u and v
while (1) {
uchain = chainInd[u];
if (uchain == vchain) {
ans += query_tree(1, 1, ptr - 1, posInBase[v], posInBase[u]);
break;
}
ans += query_tree(1, 1, ptr - 1, posInBase[chainHead[uchain]],
posInBase[u]);
u = chainHead[uchain]; // move u to u's chainHead
u = par[u][0]; // Then move to its parent, that means we changed
// chains
}
return ans;
}
ll LCA(ll u, ll v) {
if (depth[u] < depth[v])
swap(u, v);
ll diff = depth[u] - depth[v];
for (ll i = 0; i < LN; i++)
if ((diff >> i) & 1)
u = par[u][i];
if (u == v)
return u;
for (ll i = LN - 1; i >= 0; i--)
if (par[u][i] != par[v][i]) {
u = par[u][i];
v = par[v][i];
}
return par[u][0];
}
ll query(ll u, ll v) {
ll lca = LCA(u, v);
ll ans = query_up(u, lca); // One part of path
ll ans2 = query_up(v, lca); // another part of path
return ans + ans2 - query_up(lca, lca); // take the maximum of both paths
}
void change(ll u, ll val) {
update_tree(1, 1, ptr - 1, posInBase[u], val);
}
void HLD(ll curNode, ll prev) {
if (chainHead[chainNo] == -1) {
chainHead[chainNo] = curNode; // Assign chain head
}
chainInd[curNode] = chainNo;
posInBase[curNode] = ptr; // Position of this node in baseArray which we
// will use in Segtree
baseArray[ptr++] = value[curNode];
ll sc = -1, ncost;
// Loop to find special child
for (ll i = 0; i < adj[curNode].size(); i++)
if (adj[curNode][i] != prev) {
if (sc == -1 || subsize[sc] < subsize[adj[curNode][i]]) {
sc = adj[curNode][i];
}
}
if (sc != -1) {
// Expand the chain
HLD(sc, curNode);
}
for (ll i = 0; i < adj[curNode].size(); i++)
if (adj[curNode][i] != prev) {
if (sc != adj[curNode][i]) {
// New chains at each normal node
chainNo++;
HLD(adj[curNode][i], curNode);
}
}
}
void dfs(ll cur, ll prev, ll _depth = 0) {
par[cur][0] = prev;
depth[cur] = _depth;
subsize[cur] = 1;
for (ll i = 0; i < adj[cur].size(); i++)
if (adj[cur][i] != prev) {
dfs(adj[cur][i], cur, _depth + 1);
subsize[cur] += subsize[adj[cur][i]];
}
}
int main() {
#ifdef redback
freopen("C:\\Users\\Maruf\\Desktop\\in.txt", "r", stdin);
#endif
ll tc, t = 1;
scanf("%lld ", &tc);
while (tc--) {
ptr = 1;
ll n;
scanf("%lld", &n);
// Cleaning step, new test case
for (ll i = 0; i <= n; i++) {
adj[i].clear();
chainHead[i] = -1;
for (ll j = 0; j < LN; j++) par[i][j] = -1;
}
for (ll i = 0; i < n; i++) {
read(value[i]);
}
for (ll i = 1; i < n; i++) {
ll u, v, c;
scanf("%lld %lld", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
chainNo = 0;
dfs(root, -1); // We set up subsize, depth and parent for each node
HLD(root, -1); // We decomposed the tree and created baseArray
make_tree(
1, 1,
ptr -
1); // We use baseArray and construct the needed segment tree
// Below Dynamic programming code is for LCA.
for (ll lev = 1; lev <= LN - 1; lev++) {
for (ll i = 0; i < n; i++) {
if (par[i][lev - 1] != -1)
par[i][lev] = par[par[i][lev - 1]][lev - 1];
}
}
ll q;
scanf("%lld", &q);
printf("Case %lld:\n", t++);
while (q--) {
ll tp;
scanf("%lld", &tp);
ll a, b;
scanf("%lld %lld", &a, &b);
if (tp == 0) {
ll ans = query(a, b);
printf("%lld\n", ans);
} else {
change(a, b);
}
}
}
return 0;
}
| 26.443089 | 79 | 0.465796 | Maruf-Tuhin |
4b43788c40830200684afa37f82a146623c14339 | 5,748 | cpp | C++ | lib/analyzer/expressions/typeclass.cpp | reaver-project/vapor | 17ddb5c60b483bd17a288319bfd3e8a43656859e | [
"Zlib"
] | 4 | 2017-07-22T23:12:36.000Z | 2022-01-13T23:57:06.000Z | lib/analyzer/expressions/typeclass.cpp | reaver-project/vapor | 17ddb5c60b483bd17a288319bfd3e8a43656859e | [
"Zlib"
] | 36 | 2016-11-26T17:46:16.000Z | 2019-05-21T16:27:13.000Z | lib/analyzer/expressions/typeclass.cpp | reaver-project/vapor | 17ddb5c60b483bd17a288319bfd3e8a43656859e | [
"Zlib"
] | 3 | 2016-10-01T21:04:32.000Z | 2021-03-20T06:57:53.000Z | /**
* Vapor Compiler Licence
*
* Copyright © 2017-2019 Michał "Griwes" Dominiak
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation is required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
**/
#include "vapor/analyzer/expressions/typeclass.h"
#include "vapor/analyzer/expressions/overload_set.h"
#include "vapor/analyzer/semantic/symbol.h"
#include "vapor/analyzer/semantic/typeclass.h"
#include "vapor/analyzer/statements/function.h"
#include "vapor/parser/expr.h"
#include "vapor/parser/typeclass.h"
#include "expressions/typeclass.pb.h"
namespace reaver::vapor::analyzer
{
inline namespace _v1
{
std::unique_ptr<typeclass_expression> preanalyze_typeclass_literal(precontext & ctx,
const parser::typeclass_literal & parse,
scope * lex_scope)
{
return std::make_unique<typeclass_expression>(
make_node(parse), make_typeclass(ctx, parse, lex_scope));
}
typeclass_expression::typeclass_expression(ast_node parse, std::unique_ptr<typeclass> tc)
: _typeclass{ std::move(tc) }
{
_set_ast_info(parse);
}
typeclass_expression::~typeclass_expression() = default;
void typeclass_expression::print(std::ostream & os, print_context ctx) const
{
os << styles::def << ctx << styles::rule_name << "typeclass-literal";
print_address_range(os, this);
os << '\n';
auto tc_ctx = ctx.make_branch(false);
os << styles::def << tc_ctx << styles::subrule_name << "defined typeclass:\n";
_typeclass->print(os, tc_ctx.make_branch(true), true);
auto params_ctx = ctx.make_branch(_typeclass->get_member_function_decls().empty());
os << styles::def << params_ctx << styles::subrule_name << "parameters:\n";
std::size_t idx = 0;
for (auto && param : _typeclass->get_parameter_expressions())
{
param->print(os, params_ctx.make_branch(++idx == _typeclass->get_parameter_expressions().size()));
}
if (_typeclass->get_member_function_decls().size())
{
auto decl_ctx = ctx.make_branch(true);
os << styles::def << decl_ctx << styles::subrule_name << "member function declarations:\n";
std::size_t idx = 0;
for (auto && member : _typeclass->get_member_function_decls())
{
member->print(
os, decl_ctx.make_branch(++idx == _typeclass->get_member_function_decls().size()));
}
}
}
void typeclass_expression::_set_name(std::u32string name)
{
_typeclass->set_name(std::move(name));
}
future<> typeclass_expression::_analyze(analysis_context & ctx)
{
return when_all(
fmap(_typeclass->get_parameters(), [&](auto && param) { return param->analyze(ctx); }))
.then([&] {
auto param_types = fmap(_typeclass->get_parameters(), [](auto && param) {
auto ret = param->get_type();
assert(ret->is_meta());
return ret;
});
_set_type(ctx.get_typeclass_type(param_types));
})
.then([&] {
return when_all(fmap(_typeclass->get_member_function_decls(),
[&](auto && decl) { return decl->analyze(ctx); }));
})
.then([&] {
// analyze possible unresolved types in function signatures
return when_all(fmap(_typeclass->get_scope()->symbols_in_order(), [&](symbol * symb) {
auto && oset = symb->get_expression()->as<overload_set_expression>();
if (oset)
{
return when_all(fmap(oset->get_overloads(), [&](function * fn) {
return fn->return_type_expression()->analyze(ctx).then([fn, &ctx] {
return when_all(fmap(
fn->parameters(), [&](auto && param) { return param->analyze(ctx); }));
});
}));
}
return make_ready_future();
}));
});
}
std::unique_ptr<expression> typeclass_expression::_clone_expr(replacements & repl) const
{
assert(0);
}
future<expression *> typeclass_expression::_simplify_expr(recursive_context ctx)
{
return when_all(fmap(_typeclass->get_member_function_decls(), [&](auto && decl) {
return decl->simplify(ctx);
})).then([&](auto &&) -> expression * { return this; });
}
statement_ir typeclass_expression::_codegen_ir(ir_generation_context & ctx) const
{
assert(0);
}
constant_init_ir typeclass_expression::_constinit_ir(ir_generation_context &) const
{
assert(0);
}
std::unique_ptr<google::protobuf::Message> typeclass_expression::_generate_interface() const
{
return _typeclass->generate_interface();
}
}
}
| 37.324675 | 110 | 0.60421 | reaver-project |
4b438c9f87d7bc33cfe4d9a966bba4f1e2767a67 | 3,036 | cpp | C++ | sp/src/game/client/dbr/hud_hull.cpp | URAKOLOUY5/source-sdk-2013 | d6e2d4b6d3e93b1224e6b4aa378d05309eee20bc | [
"Unlicense"
] | 2 | 2022-02-18T18:16:37.000Z | 2022-02-23T21:21:37.000Z | sp/src/game/client/dbr/hud_hull.cpp | URAKOLOUY5/u5-maps | d6e2d4b6d3e93b1224e6b4aa378d05309eee20bc | [
"Unlicense"
] | null | null | null | sp/src/game/client/dbr/hud_hull.cpp | URAKOLOUY5/u5-maps | d6e2d4b6d3e93b1224e6b4aa378d05309eee20bc | [
"Unlicense"
] | null | null | null | #include "cbase.h"
#include "hud.h"
#include "hud_macros.h"
#include "c_baseplayer.h"
#include "hud_hull.h"
#include "iclientmode.h"
#include "vgui/ISurface.h"
using namespace vgui;
#include "tier0/memdbgon.h"
#ifndef DBR
DECLARE_HUDELEMENT (CHudHull);
#endif
# define HULL_INIT 80
//------------------------------------------------------------------------
// Purpose: Constructor
//------------------------------------------------------------------------
CHudHull:: CHudHull (const char * pElementName) :
CHudElement (pElementName), BaseClass (NULL, "HudHull")
{
vgui:: Panel * pParent = g_pClientMode-> GetViewport ();
SetParent (pParent);
SetHiddenBits (HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD | HIDEHUD_NEEDSUIT);
}
//------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------
void CHudHull:: Init()
{
Reset();
}
//------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------
void CHudHull:: Reset (void)
{
m_flHull = HULL_INIT;
m_nHullLow = -1;
SetBgColor (Color (0,0,0,0));
}
//------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------
void CHudHull:: OnThink (void)
{
float newHull = 0;
C_BasePlayer * local = C_BasePlayer:: GetLocalPlayer ();
if (!local)
return;
// Never below zero
newHull = max(local->GetHealth(), 0);
// DevMsg("Sheild at is at: %f\n",newShield);
// Only update the fade if we've changed health
if (newHull == m_flHull)
return;
m_flHull = newHull;
}
//------------------------------------------------------------------------
// Purpose: draws the power bar
//------------------------------------------------------------------------
void CHudHull::Paint()
{
// Get bar chunks
int chunkCount = m_flBarWidth / (m_flBarChunkWidth + m_flBarChunkGap);
int enabledChunks = (int)((float)chunkCount * (m_flHull / 100.0f) + 0.5f );
// Draw the suit power bar
surface()->DrawSetColor (m_HullColor);
int xpos = m_flBarInsetX, ypos = m_flBarInsetY;
for (int i = 0; i < enabledChunks; i++)
{
surface()->DrawFilledRect(xpos, ypos, xpos + m_flBarChunkWidth, ypos + m_flBarHeight);
xpos += (m_flBarChunkWidth + m_flBarChunkGap);
}
// Draw the exhausted portion of the bar.
surface()->DrawSetColor(Color(m_HullColor [0], m_HullColor [1], m_HullColor [2], m_iHullDisabledAlpha));
for (int i = enabledChunks; i < chunkCount; i++)
{
surface()->DrawFilledRect(xpos, ypos, xpos + m_flBarChunkWidth, ypos + m_flBarHeight);
xpos += (m_flBarChunkWidth + m_flBarChunkGap);
}
// Draw our name
surface()->DrawSetTextFont(m_hTextFont);
surface()->DrawSetTextColor(m_HullColor);
surface()->DrawSetTextPos(text_xpos, text_ypos);
//wchar_t *tempString = vgui::localize()->Find("#Valve_Hud_AUX_POWER");
surface()->DrawPrintText(L"HULL", wcslen(L"HULL"));
} | 26.172414 | 105 | 0.525033 | URAKOLOUY5 |
4b45421dcb8c6a9168ef3b3b2d44ed2d2dbd917b | 19,308 | cxx | C++ | Rendering/VR/vtkVRRenderWindow.cxx | jpouderoux/VTK | 1af22bcce698e121b6c8064ea724636621d1bf7e | [
"BSD-3-Clause"
] | 1 | 2021-11-23T02:09:28.000Z | 2021-11-23T02:09:28.000Z | Rendering/VR/vtkVRRenderWindow.cxx | zist8888/VTK | 74ae7be4aa33c94b0535ebbdaf7d27573d7c7614 | [
"BSD-3-Clause"
] | null | null | null | Rendering/VR/vtkVRRenderWindow.cxx | zist8888/VTK | 74ae7be4aa33c94b0535ebbdaf7d27573d7c7614 | [
"BSD-3-Clause"
] | null | null | null | /*=========================================================================
Program: Visualization Toolkit
Module: vtkVRRenderWindow.cxx
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkVRRenderWindow.h"
#include "vtkMatrix4x4.h"
#include "vtkObjectFactory.h"
#include "vtkOpenGLError.h"
#include "vtkOpenGLRenderWindow.h"
#include "vtkOpenGLState.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRenderer.h"
#include "vtkRendererCollection.h"
#include "vtkTransform.h"
#include "vtkVRCamera.h"
#include "vtkVRModel.h"
#include "vtkVRRenderer.h"
#include <cstring>
#include <memory>
// include what we need for the helper window
#ifdef WIN32
#include "vtkWin32OpenGLRenderWindow.h"
#endif
#ifdef VTK_USE_X
#include "vtkXOpenGLRenderWindow.h"
#endif
#ifdef VTK_USE_COCOA
#include "vtkCocoaRenderWindow.h"
#endif
#if !defined(_WIN32) || defined(__CYGWIN__)
#define stricmp strcasecmp
#endif
//------------------------------------------------------------------------------
vtkVRRenderWindow::vtkVRRenderWindow()
{
this->StereoCapableWindow = 1;
this->StereoRender = 1;
this->UseOffScreenBuffers = true;
this->Size[0] = 640;
this->Size[1] = 720;
this->Position[0] = 100;
this->Position[1] = 100;
this->HelperWindow = vtkOpenGLRenderWindow::SafeDownCast(vtkRenderWindow::New());
if (!this->HelperWindow)
{
vtkErrorMacro(<< "Failed to create render window");
}
}
//------------------------------------------------------------------------------
vtkVRRenderWindow::~vtkVRRenderWindow()
{
this->Finalize();
vtkRenderer* ren;
vtkCollectionSimpleIterator rit;
this->Renderers->InitTraversal(rit);
while ((ren = this->Renderers->GetNextRenderer(rit)))
{
ren->SetRenderWindow(nullptr);
}
if (this->HelperWindow)
{
this->HelperWindow->Delete();
}
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os, indent);
os << indent << "ContextId: " << this->HelperWindow->GetGenericContext() << "\n";
os << indent << "Window Id: " << this->HelperWindow->GetGenericWindowId() << "\n";
os << indent << "Initialized: " << this->Initialized << "\n";
os << indent << "PhysicalViewDirection: (" << this->PhysicalViewDirection[0] << ", "
<< this->PhysicalViewDirection[1] << ", " << this->PhysicalViewDirection[2] << ")\n";
os << indent << "PhysicalViewUp: (" << this->PhysicalViewUp[0] << ", " << this->PhysicalViewUp[1]
<< ", " << this->PhysicalViewUp[2] << ")\n";
os << indent << "PhysicalTranslation: (" << this->PhysicalTranslation[0] << ", "
<< this->PhysicalTranslation[1] << ", " << this->PhysicalTranslation[2] << ")\n";
os << indent << "PhysicalScale: " << this->PhysicalScale << "\n";
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::ReleaseGraphicsResources(vtkWindow* renWin)
{
this->Superclass::ReleaseGraphicsResources(renWin);
for (FramebufferDesc& fbo : this->FramebufferDescs)
{
glDeleteFramebuffers(1, &fbo.ResolveFramebufferId);
}
for (auto& model : this->DeviceHandleToDeviceDataMap)
{
if (model.second.Model)
{
model.second.Model->ReleaseGraphicsResources(renWin);
}
}
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::SetHelperWindow(vtkOpenGLRenderWindow* win)
{
if (this->HelperWindow == win)
{
return;
}
if (this->HelperWindow)
{
this->ReleaseGraphicsResources(this);
this->HelperWindow->Delete();
}
this->HelperWindow = win;
if (win)
{
win->Register(this);
}
this->Modified();
}
void vtkVRRenderWindow::AddDeviceHandle(uint32_t handle)
{
auto found = this->DeviceHandleToDeviceDataMap.find(handle);
if (found == this->DeviceHandleToDeviceDataMap.end())
{
this->DeviceHandleToDeviceDataMap[handle] = {};
}
}
void vtkVRRenderWindow::AddDeviceHandle(uint32_t handle, vtkEventDataDevice device)
{
auto found = this->DeviceHandleToDeviceDataMap.find(handle);
if (found == this->DeviceHandleToDeviceDataMap.end())
{
this->DeviceHandleToDeviceDataMap[handle] = {};
found = this->DeviceHandleToDeviceDataMap.find(handle);
}
found->second.Device = device;
}
void vtkVRRenderWindow::SetModelForDeviceHandle(uint32_t handle, vtkVRModel* model)
{
auto found = this->DeviceHandleToDeviceDataMap.find(handle);
if (found == this->DeviceHandleToDeviceDataMap.end())
{
this->DeviceHandleToDeviceDataMap[handle] = {};
found = this->DeviceHandleToDeviceDataMap.find(handle);
}
found->second.Model = model;
}
vtkVRModel* vtkVRRenderWindow::GetModelForDevice(vtkEventDataDevice idx)
{
auto handle = this->GetDeviceHandleForDevice(idx);
return this->GetModelForDeviceHandle(handle);
}
vtkVRModel* vtkVRRenderWindow::GetModelForDeviceHandle(uint32_t handle)
{
auto found = this->DeviceHandleToDeviceDataMap.find(handle);
if (found == this->DeviceHandleToDeviceDataMap.end())
{
return nullptr;
}
return found->second.Model;
}
vtkMatrix4x4* vtkVRRenderWindow::GetDeviceToPhysicalMatrixForDevice(vtkEventDataDevice idx)
{
auto handle = this->GetDeviceHandleForDevice(idx);
return this->GetDeviceToPhysicalMatrixForDeviceHandle(handle);
}
vtkMatrix4x4* vtkVRRenderWindow::GetDeviceToPhysicalMatrixForDeviceHandle(uint32_t handle)
{
auto found = this->DeviceHandleToDeviceDataMap.find(handle);
if (found == this->DeviceHandleToDeviceDataMap.end())
{
return nullptr;
}
return found->second.Pose;
}
uint32_t vtkVRRenderWindow::GetDeviceHandleForDevice(vtkEventDataDevice idx, uint32_t index)
{
for (auto& deviceData : this->DeviceHandleToDeviceDataMap)
{
if (deviceData.second.Device == idx && deviceData.second.Index == index)
{
return deviceData.first;
}
}
return InvalidDeviceIndex;
}
uint32_t vtkVRRenderWindow::GetNumberOfDeviceHandlesForDevice(vtkEventDataDevice dev)
{
uint32_t count = 0;
for (auto& deviceData : this->DeviceHandleToDeviceDataMap)
{
if (deviceData.second.Device == dev)
{
count++;
}
}
return count;
}
// default implementation just uses the vtkEventDataDevice
vtkEventDataDevice vtkVRRenderWindow::GetDeviceForDeviceHandle(uint32_t handle)
{
auto found = this->DeviceHandleToDeviceDataMap.find(handle);
if (found == this->DeviceHandleToDeviceDataMap.end())
{
return vtkEventDataDevice::Unknown;
}
return found->second.Device;
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::InitializeViewFromCamera(vtkCamera* srccam)
{
vtkRenderer* ren = vtkRenderer::SafeDownCast(this->GetRenderers()->GetItemAsObject(0));
if (!ren)
{
vtkErrorMacro("The renderer must be set prior to calling InitializeViewFromCamera");
return;
}
vtkVRCamera* cam = vtkVRCamera::SafeDownCast(ren->GetActiveCamera());
if (!cam)
{
vtkErrorMacro(
"The renderer's active camera must be set prior to calling InitializeViewFromCamera");
return;
}
// make sure the view up is reasonable based on the view up
// that was set in PV
double distance = sin(vtkMath::RadiansFromDegrees(srccam->GetViewAngle()) / 2.0) *
srccam->GetDistance() / sin(vtkMath::RadiansFromDegrees(cam->GetViewAngle()) / 2.0);
double* oldVup = srccam->GetViewUp();
int maxIdx = fabs(oldVup[0]) > fabs(oldVup[1]) ? (fabs(oldVup[0]) > fabs(oldVup[2]) ? 0 : 2)
: (fabs(oldVup[1]) > fabs(oldVup[2]) ? 1 : 2);
cam->SetViewUp((maxIdx == 0 ? (oldVup[0] > 0 ? 1 : -1) : 0.0),
(maxIdx == 1 ? (oldVup[1] > 0 ? 1 : -1) : 0.0), (maxIdx == 2 ? (oldVup[2] > 0 ? 1 : -1) : 0.0));
this->SetPhysicalViewUp((maxIdx == 0 ? (oldVup[0] > 0 ? 1 : -1) : 0.0),
(maxIdx == 1 ? (oldVup[1] > 0 ? 1 : -1) : 0.0), (maxIdx == 2 ? (oldVup[2] > 0 ? 1 : -1) : 0.0));
double* oldFP = srccam->GetFocalPoint();
double* cvup = cam->GetViewUp();
cam->SetFocalPoint(oldFP);
this->SetPhysicalTranslation(
cvup[0] * distance - oldFP[0], cvup[1] * distance - oldFP[1], cvup[2] * distance - oldFP[2]);
this->SetPhysicalScale(distance);
double* oldDOP = srccam->GetDirectionOfProjection();
int dopMaxIdx = fabs(oldDOP[0]) > fabs(oldDOP[1]) ? (fabs(oldDOP[0]) > fabs(oldDOP[2]) ? 0 : 2)
: (fabs(oldDOP[1]) > fabs(oldDOP[2]) ? 1 : 2);
this->SetPhysicalViewDirection((dopMaxIdx == 0 ? (oldDOP[0] > 0 ? 1 : -1) : 0.0),
(dopMaxIdx == 1 ? (oldDOP[1] > 0 ? 1 : -1) : 0.0),
(dopMaxIdx == 2 ? (oldDOP[2] > 0 ? 1 : -1) : 0.0));
double* idop = this->GetPhysicalViewDirection();
cam->SetPosition(
-idop[0] * distance + oldFP[0], -idop[1] * distance + oldFP[1], -idop[2] * distance + oldFP[2]);
ren->ResetCameraClippingRange();
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::MakeCurrent()
{
if (this->HelperWindow)
{
this->HelperWindow->MakeCurrent();
}
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::ReleaseCurrent()
{
if (this->HelperWindow)
{
this->HelperWindow->ReleaseCurrent();
}
}
//------------------------------------------------------------------------------
vtkOpenGLState* vtkVRRenderWindow::GetState()
{
if (this->HelperWindow)
{
return this->HelperWindow->GetState();
}
return this->Superclass::GetState();
}
//------------------------------------------------------------------------------
bool vtkVRRenderWindow::IsCurrent()
{
return this->HelperWindow ? this->HelperWindow->IsCurrent() : false;
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::AddRenderer(vtkRenderer* ren)
{
if (ren && !vtkVRRenderer::SafeDownCast(ren))
{
vtkErrorMacro("vtkVRRenderWindow::AddRenderer: Failed to add renderer of type "
<< ren->GetClassName() << ": A subclass of vtkVRRenderer is expected");
return;
}
this->Superclass::AddRenderer(ren);
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::Start()
{
// if the renderer has not been initialized, do so now
if (this->HelperWindow && !this->Initialized)
{
this->Initialize();
}
this->Superclass::Start();
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::Initialize()
{
if (this->Initialized)
{
return;
}
this->GetSizeFromAPI();
this->HelperWindow->SetDisplayId(this->GetGenericDisplayId());
this->HelperWindow->SetShowWindow(false);
this->HelperWindow->Initialize();
this->MakeCurrent();
this->OpenGLInit();
// some classes override the ivar in a getter :-(
this->MaximumHardwareLineWidth = this->HelperWindow->GetMaximumHardwareLineWidth();
glDepthRange(0., 1.);
this->SetWindowName(this->GetWindowTitleFromAPI().c_str());
this->CreateFramebuffers();
this->Initialized = true;
vtkDebugMacro(<< "End of VRRenderWindow Initialization");
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::Finalize()
{
this->ReleaseGraphicsResources(this);
this->DeviceHandleToDeviceDataMap.clear();
if (this->HelperWindow && this->HelperWindow->GetGenericContext())
{
this->HelperWindow->Finalize();
}
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::Render()
{
this->MakeCurrent();
this->GetState()->ResetGLViewportState();
this->Superclass::Render();
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::RenderFramebuffer(FramebufferDesc& framebufferDesc)
{
this->GetState()->PushDrawFramebufferBinding();
this->GetState()->vtkglBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferDesc.ResolveFramebufferId);
glBlitFramebuffer(0, 0, this->Size[0], this->Size[1], 0, 0, this->Size[0], this->Size[1],
GL_COLOR_BUFFER_BIT, GL_LINEAR);
if (framebufferDesc.ResolveDepthTextureId != 0)
{
glBlitFramebuffer(0, 0, this->Size[0], this->Size[1], 0, 0, this->Size[0], this->Size[1],
GL_DEPTH_BUFFER_BIT, GL_NEAREST);
}
this->GetState()->PopDrawFramebufferBinding();
}
//------------------------------------------------------------------------------
bool vtkVRRenderWindow::GetDeviceToWorldMatrixForDevice(
vtkEventDataDevice device, vtkMatrix4x4* deviceToWorldMatrix)
{
vtkMatrix4x4* deviceToPhysicalMatrix = this->GetDeviceToPhysicalMatrixForDevice(device);
if (deviceToPhysicalMatrix)
{
// we use deviceToWorldMatrix here to temporarily store physicalToWorld
// to avoid having to use a temp matrix. We use a new pointer just to
// keep the code easier to read.
vtkMatrix4x4* physicalToWorldMatrix = deviceToWorldMatrix;
this->GetPhysicalToWorldMatrix(physicalToWorldMatrix);
vtkMatrix4x4::Multiply4x4(physicalToWorldMatrix, deviceToPhysicalMatrix, deviceToWorldMatrix);
return true;
}
return false;
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::SetPhysicalViewDirection(double x, double y, double z)
{
if (this->PhysicalViewDirection[0] != x || this->PhysicalViewDirection[1] != y ||
this->PhysicalViewDirection[2] != z)
{
this->PhysicalViewDirection[0] = x;
this->PhysicalViewDirection[1] = y;
this->PhysicalViewDirection[2] = z;
this->InvokeEvent(vtkVRRenderWindow::PhysicalToWorldMatrixModified);
this->Modified();
}
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::SetPhysicalViewDirection(double dir[3])
{
this->SetPhysicalViewDirection(dir[0], dir[1], dir[2]);
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::SetPhysicalViewUp(double x, double y, double z)
{
if (this->PhysicalViewUp[0] != x || this->PhysicalViewUp[1] != y || this->PhysicalViewUp[2] != z)
{
this->PhysicalViewUp[0] = x;
this->PhysicalViewUp[1] = y;
this->PhysicalViewUp[2] = z;
this->InvokeEvent(vtkVRRenderWindow::PhysicalToWorldMatrixModified);
this->Modified();
}
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::SetPhysicalViewUp(double dir[3])
{
this->SetPhysicalViewUp(dir[0], dir[1], dir[2]);
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::SetPhysicalTranslation(double x, double y, double z)
{
if (this->PhysicalTranslation[0] != x || this->PhysicalTranslation[1] != y ||
this->PhysicalTranslation[2] != z)
{
this->PhysicalTranslation[0] = x;
this->PhysicalTranslation[1] = y;
this->PhysicalTranslation[2] = z;
this->InvokeEvent(vtkVRRenderWindow::PhysicalToWorldMatrixModified);
this->Modified();
}
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::SetPhysicalTranslation(double trans[3])
{
this->SetPhysicalTranslation(trans[0], trans[1], trans[2]);
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::SetPhysicalScale(double scale)
{
if (this->PhysicalScale != scale)
{
this->PhysicalScale = scale;
this->InvokeEvent(vtkVRRenderWindow::PhysicalToWorldMatrixModified);
this->Modified();
}
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::SetPhysicalToWorldMatrix(vtkMatrix4x4* matrix)
{
if (!matrix)
{
return;
}
vtkNew<vtkMatrix4x4> currentPhysicalToWorldMatrix;
this->GetPhysicalToWorldMatrix(currentPhysicalToWorldMatrix);
bool matrixDifferent = false;
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
if (fabs(matrix->GetElement(i, j) - currentPhysicalToWorldMatrix->GetElement(i, j)) >= 1e-3)
{
matrixDifferent = true;
break;
}
}
}
if (!matrixDifferent)
{
return;
}
vtkNew<vtkTransform> hmdToWorldTransform;
hmdToWorldTransform->SetMatrix(matrix);
double translation[3] = { 0.0 };
hmdToWorldTransform->GetPosition(translation);
this->PhysicalTranslation[0] = (-1.0) * translation[0];
this->PhysicalTranslation[1] = (-1.0) * translation[1];
this->PhysicalTranslation[2] = (-1.0) * translation[2];
double scale[3] = { 0.0 };
hmdToWorldTransform->GetScale(scale);
this->PhysicalScale = scale[0];
this->PhysicalViewUp[0] = matrix->GetElement(0, 1);
this->PhysicalViewUp[1] = matrix->GetElement(1, 1);
this->PhysicalViewUp[2] = matrix->GetElement(2, 1);
vtkMath::Normalize(this->PhysicalViewUp);
this->PhysicalViewDirection[0] = (-1.0) * matrix->GetElement(0, 2);
this->PhysicalViewDirection[1] = (-1.0) * matrix->GetElement(1, 2);
this->PhysicalViewDirection[2] = (-1.0) * matrix->GetElement(2, 2);
vtkMath::Normalize(this->PhysicalViewDirection);
this->InvokeEvent(vtkVRRenderWindow::PhysicalToWorldMatrixModified);
this->Modified();
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::GetPhysicalToWorldMatrix(vtkMatrix4x4* physicalToWorldMatrix)
{
if (!physicalToWorldMatrix)
{
return;
}
physicalToWorldMatrix->Identity();
// construct physical to non-scaled world axes (scaling is applied later)
double physicalZ_NonscaledWorld[3] = { -this->PhysicalViewDirection[0],
-this->PhysicalViewDirection[1], -this->PhysicalViewDirection[2] };
double* physicalY_NonscaledWorld = this->PhysicalViewUp;
double physicalX_NonscaledWorld[3] = { 0.0 };
vtkMath::Cross(physicalY_NonscaledWorld, physicalZ_NonscaledWorld, physicalX_NonscaledWorld);
for (int row = 0; row < 3; ++row)
{
physicalToWorldMatrix->SetElement(row, 0, physicalX_NonscaledWorld[row] * this->PhysicalScale);
physicalToWorldMatrix->SetElement(row, 1, physicalY_NonscaledWorld[row] * this->PhysicalScale);
physicalToWorldMatrix->SetElement(row, 2, physicalZ_NonscaledWorld[row] * this->PhysicalScale);
physicalToWorldMatrix->SetElement(row, 3, -this->PhysicalTranslation[row]);
}
}
//------------------------------------------------------------------------------
int* vtkVRRenderWindow::GetScreenSize()
{
if (this->GetSizeFromAPI())
{
this->ScreenSize[0] = this->Size[0];
this->ScreenSize[1] = this->Size[1];
}
return this->ScreenSize;
}
//------------------------------------------------------------------------------
void vtkVRRenderWindow::SetSize(int width, int height)
{
if ((this->Size[0] != width) || (this->Size[1] != height))
{
this->Superclass::SetSize(width, height);
if (this->Interactor)
{
this->Interactor->SetSize(width, height);
}
}
}
| 31.497553 | 100 | 0.610317 | jpouderoux |
4b456dc0150daf1a1979db5991fec39e2c70fefe | 732 | cpp | C++ | Ticker.cpp | quyse/inanity | a39225c5a41f879abe5aa492bb22b500dbe77433 | [
"MIT"
] | 26 | 2015-04-22T05:25:25.000Z | 2020-11-15T11:07:56.000Z | Ticker.cpp | quyse/inanity | a39225c5a41f879abe5aa492bb22b500dbe77433 | [
"MIT"
] | 2 | 2015-01-05T10:41:27.000Z | 2015-01-06T20:46:11.000Z | Ticker.cpp | quyse/inanity | a39225c5a41f879abe5aa492bb22b500dbe77433 | [
"MIT"
] | 5 | 2016-08-02T11:13:57.000Z | 2018-10-26T11:19:27.000Z | #include "Ticker.hpp"
BEGIN_INANITY
Ticker::Ticker() :
lastTick(-1),
pauseTick(-1)
{
tickCoef = 1.0f / Time::GetTicksPerSecond();
}
void Ticker::Pause()
{
// if already paused, do nothing
if(pauseTick >= 0)
return;
// remember pause time
pauseTick = Time::GetTick();
}
float Ticker::Tick()
{
// get current time
Time::Tick currentTick = Time::GetTick();
// calculate amount of ticks from last tick
Time::Tick ticks = 0;
if(lastTick >= 0)
{
if(pauseTick >= 0)
ticks = pauseTick - lastTick;
else
ticks = currentTick - lastTick;
}
// if was paused, resume
if(pauseTick >= 0)
pauseTick = -1;
// remember current tick as last tick
lastTick = currentTick;
return ticks * tickCoef;
}
END_INANITY
| 15.25 | 45 | 0.659836 | quyse |
4b4571a1dcce05248083a5fc2bc7cf8acfc8de44 | 1,851 | cpp | C++ | Code/Libraries/Rodin/src/BTNodes/rodinbtnodeuseresource.cpp | lihop/Eldritch | bb38ff8ad59e4c1f11b1430ef482e60f7618a280 | [
"Zlib"
] | 4 | 2019-09-15T20:00:23.000Z | 2021-08-27T23:32:53.000Z | Code/Libraries/Rodin/src/BTNodes/rodinbtnodeuseresource.cpp | lihop/Eldritch | bb38ff8ad59e4c1f11b1430ef482e60f7618a280 | [
"Zlib"
] | null | null | null | Code/Libraries/Rodin/src/BTNodes/rodinbtnodeuseresource.cpp | lihop/Eldritch | bb38ff8ad59e4c1f11b1430ef482e60f7618a280 | [
"Zlib"
] | 1 | 2021-03-27T11:27:03.000Z | 2021-03-27T11:27:03.000Z | #include "core.h"
#include "rodinbtnodeuseresource.h"
#include "configmanager.h"
#include "Components/wbcomprodinresourcemap.h"
#include "Components/wbcomprodinbehaviortree.h"
#include "wbentity.h"
RodinBTNodeUseResource::RodinBTNodeUseResource()
: m_Resource()
, m_ForceClaim( false )
{
}
RodinBTNodeUseResource::~RodinBTNodeUseResource()
{
}
void RodinBTNodeUseResource::InitializeFromDefinition( const SimpleString& DefinitionName )
{
RodinBTNodeDecorator::InitializeFromDefinition( DefinitionName );
MAKEHASH( DefinitionName );
STATICHASH( Resource );
m_Resource = ConfigManager::GetHash( sResource, HashedString::NullString, sDefinitionName );
STATICHASH( ForceClaim );
m_ForceClaim = ConfigManager::GetBool( sForceClaim, false, sDefinitionName );
}
/*virtual*/ RodinBTNode::ETickStatus RodinBTNodeUseResource::Tick( const float DeltaTime )
{
WBCompRodinResourceMap* const pResourceMap = GET_WBCOMP( GetEntity(), RodinResourceMap );
ASSERT( pResourceMap );
if( m_ChildStatus != ETS_None )
{
// We're just continuing from being woken.
return RodinBTNodeDecorator::Tick( DeltaTime );
}
if( pResourceMap->ClaimResource( this, m_Resource, m_ForceClaim ) )
{
// We got the resource, we're all good (or we're just continuing from being woken).
return RodinBTNodeDecorator::Tick( DeltaTime );
}
else
{
// We couldn't get the resource.
return ETS_Fail;
}
}
/*virtual*/ void RodinBTNodeUseResource::OnFinish()
{
RodinBTNodeDecorator::OnFinish();
WBCompRodinResourceMap* const pResourceMap = GET_WBCOMP( GetEntity(), RodinResourceMap );
ASSERT( pResourceMap );
pResourceMap->ReleaseResource( this, m_Resource );
}
/*virtual*/ bool RodinBTNodeUseResource::OnResourceStolen( const HashedString& Resource )
{
Unused( Resource );
ASSERT( Resource == m_Resource );
m_BehaviorTree->Stop( this );
return false;
} | 26.070423 | 93 | 0.763911 | lihop |
4b4a53a88a31216c53148baa1ab0b86d8d60022f | 14,142 | cpp | C++ | src/client/client/Command_Client_Engine.cpp | Kuga23/Projet-M2 | 85c879b8fd1ed4fdf89eedd9f89841cbd7a1e433 | [
"MIT"
] | null | null | null | src/client/client/Command_Client_Engine.cpp | Kuga23/Projet-M2 | 85c879b8fd1ed4fdf89eedd9f89841cbd7a1e433 | [
"MIT"
] | null | null | null | src/client/client/Command_Client_Engine.cpp | Kuga23/Projet-M2 | 85c879b8fd1ed4fdf89eedd9f89841cbd7a1e433 | [
"MIT"
] | null | null | null | #include <iostream>
#include <functional>
#include <unistd.h>
#include "Command_Client_Engine.h"
#include "state.h"
#include "render.h"
#include "engine.h"
using namespace client;
using namespace render;
using namespace engine;
using namespace state;
using namespace std;
Command_Client_Engine::Command_Client_Engine() {
}
Command_Client_Engine::~Command_Client_Engine(){
}
void Command_Client_Engine::execute() {
cout << "TEST ENGINE" << endl;
Engine engine;
engine.getState().setMode("engine");
engine.getState().initPlayers();
engine.getState().initCharacters();
engine.getState().initMapCell();
cout << " INIT DONE" << endl;
sf::RenderWindow window(sf::VideoMode(32 * 26 + 500, 32 * 24), "Zorglub");
StateLayer stateLayer(engine.getState(), window);
stateLayer.initTextureArea(engine.getState());
StateLayer *ptr_stateLayer = &stateLayer;
engine.getState().registerObserver(ptr_stateLayer);
bool booting = true;
bool firstround = true;
bool secondroun = false;
bool thirdround = false;
bool fourround = false;
bool fiveround = false;
bool sixround = false;
int p1X;
int p1Y;
int p2X;
int p2Y;
int priority;
// hard code health bc its loong either wise
engine.getState().getListCharacters(0)[0]->setNewHealth(25);
engine.getState().getListCharacters(0)[0]->setPrecision(15, 15, 15, 15);// precision to 1
engine.getState().getListCharacters(0)[0]->setDodge(8, 8);// set dodge to 0
engine.getState().getListCharacters(1)[0]->setNewHealth(25);
engine.getState().getListCharacters(1)[0]->setPrecision(15, 15, 15, 15);// precision to 1
engine.getState().getListCharacters(1)[0]->setDodge(8, 8);// set dodge to 0
engine.getState().getListCharacters(1)[0]->getCharWeap()->setTypeCapab(TELEPORT); // Teleport Capacity
while (window.isOpen()) {
sf::Event event;
if (booting) {
stateLayer.draw(window);
booting = false;
}
while (1) {
if (firstround) {
p1X = engine.getState().getListCharacters(0)[0]->getPosition().getX();
p1Y = engine.getState().getListCharacters(0)[0]->getPosition().getY();
int priority = 0;
cout << "[Player 1] Character pos( " << engine.getState().getListCharacters(0)[0]->getPosition().getX()
<< " " << engine.getState().getListCharacters(0)[0]->getPosition().getY() << endl;
unique_ptr <engine::Command> ptr_sc(
new engine::Sel_Char_Command(*engine.getState().getListCharacters(0)[0]));
engine.addCommand(move(ptr_sc), priority++);
//cout<< "The First Plyaer Character has been Selected: Sel_Char_Command"<<endl;
engine.getState().setCurAction(MOVING); // hard change the sate cur action
Position pos1{p1X, ++p1Y};
unique_ptr <engine::Command> ptr_mc1(
new engine::Move_Command(*engine.getState().getListCharacters(0)[0], pos1));
engine.addCommand(move(ptr_mc1), priority++);
cout << "MOVE FROM pos(" << p1X << "," << p1Y << ")" << " TO " << "(" << p1X << "," << p1Y + 1 << ")"
<< endl;
if (engine.getState().getListCharacters(0)[0]->getMovementLeft() == 0) {
engine.getState().setCurAction(ATTACKING); // Hard set Attacking mode
cout << "STATE IN ATTACING MODE: SHOW ATTACK RANGE" << endl;
unique_ptr <engine::Command> ptr_ftc(new engine::Finish_Turn_Command());
engine.addCommand(move(ptr_ftc), priority++);
cout << "FINISHING TURN" << endl;
firstround = false;
secondroun = true;
}
engine.update();
}
if (secondroun) {
engine.getState().setCurAction(IDLE);
//Player 2
p2X = engine.getState().getListCharacters(1)[0]->getPosition().getX();
p2Y = engine.getState().getListCharacters(1)[0]->getPosition().getY();
priority = 0;
cout << "[Player 2] Character pos( " << engine.getState().getListCharacters(1)[0]->getPosition().getX()
<< " " << engine.getState().getListCharacters(1)[0]->getPosition().getY() << endl;
unique_ptr <engine::Command> ptr_sc(
new engine::Sel_Char_Command(*engine.getState().getListCharacters(1)[0]));
engine.addCommand(move(ptr_sc), priority++);
//cout<< "The First Plyaer Character has been Selected: Sel_Char_Command"<<endl;
engine.getState().setCurAction(MOVING); // hard change the sate cur action
Position pos1{p2X, --p2Y};
unique_ptr <engine::Command> ptr_mc2(
new engine::Move_Command(*engine.getState().getListCharacters(1)[0], pos1));
engine.addCommand(move(ptr_mc2), priority++);
cout << "MOVE FROM pos(" << p2X << "," << p2Y << ")" << " TO " << "(" << p2X << "," << p2Y + 1 << ")"
<< endl;
if (engine.getState().getListCharacters(1)[0]->getMovementLeft() == 0) {
engine.getState().setCurAction(ATTACKING);// Show the attack range
cout << "STATE IN ATTACING MODE: SHOW ATTACK RANGE" << endl;
unique_ptr <engine::Command> ptr_ftc(new engine::Finish_Turn_Command());
engine.addCommand(move(ptr_ftc), priority++);
cout << "FINISHING TURN" << endl;
secondroun = false;
thirdround = true;
}
engine.update();
}
if (thirdround) {
engine.getState().setCurAction(IDLE);
p1X = engine.getState().getListCharacters(0)[0]->getPosition().getX();
p1Y = engine.getState().getListCharacters(0)[0]->getPosition().getY();
int priority = 0;
cout << "[Player 1] Character pos( " << engine.getState().getListCharacters(0)[0]->getPosition().getX()
<< " " << engine.getState().getListCharacters(0)[0]->getPosition().getY() << endl;
unique_ptr <engine::Command> ptr_sc(
new engine::Sel_Char_Command(*engine.getState().getListCharacters(0)[0]));
engine.addCommand(move(ptr_sc), priority++);
//cout<< "The First Plyaer Character has been Selected: Sel_Char_Command"<<endl;
engine.getState().setCurAction(MOVING); // hard change the sate cur action
Position pos1{p1X, ++p1Y};
unique_ptr <engine::Command> ptr_mc1(
new engine::Move_Command(*engine.getState().getListCharacters(0)[0], pos1));
engine.addCommand(move(ptr_mc1), priority++);
cout << "MOVE FROM pos(" << p1X << "," << p1Y << ")" << " TO " << "(" << p1X << "," << p1Y + 1 << ")"
<< endl;
if (engine.getState().getListCharacters(0)[0]->getMovementLeft() == 0) {
engine.getState().setCurAction(ATTACKING); // Hard set Attacking mode
cout << "STATE IN ATTACING MODE: SHOW ATTACK RANGE" << endl;
unique_ptr <engine::Command> ptr_ftc(new engine::Finish_Turn_Command());
engine.addCommand(move(ptr_ftc), priority++);
cout << "FINISHING TURN" << endl;
thirdround = false;
fourround = true;
}
engine.update();
}
if (fourround) {
engine.getState().setCurAction(IDLE);
//Player 2
p2X = engine.getState().getListCharacters(1)[0]->getPosition().getX();
p2Y = engine.getState().getListCharacters(1)[0]->getPosition().getY();
priority = 0;
cout << "[Player 2] Character pos( " << engine.getState().getListCharacters(1)[0]->getPosition().getX()
<< " " << engine.getState().getListCharacters(1)[0]->getPosition().getY() << endl;
unique_ptr <engine::Command> ptr_sc(
new engine::Sel_Char_Command(*engine.getState().getListCharacters(1)[0]));
engine.addCommand(move(ptr_sc), priority++);
//cout<< "The First Plyaer Character has been Selected: Sel_Char_Command"<<endl;
engine.getState().setCurAction(MOVING); // hard change the sate cur action
Position pos1{p2X, --p2Y};
unique_ptr <engine::Command> ptr_mc2(
new engine::Move_Command(*engine.getState().getListCharacters(1)[0], pos1));
engine.addCommand(move(ptr_mc2), priority++);
cout << "MOVE FROM pos(" << p2X << "," << p2Y << ")" << " TO " << "(" << p2X << "," << p2Y + 1 << ")"
<< endl;
if (engine.getState().getListCharacters(1)[0]->getMovementLeft() == 3) { // has reach attack range
// ==3 because the update isn't done yet
engine.getState().setCurAction(ATTACKING);// Show the attack range
cout << "STATE IN ATTACING MODE: SHOW ATTACK RANGE" << endl;
unique_ptr <engine::Command> ptr_ac2(
new engine::Attack_Command(*engine.getState().getListCharacters(1)[0],
*engine.getState().getListCharacters(0)[0]));
engine.addCommand(move(ptr_ac2), priority++);
cout << "ATTACKED";
unique_ptr <engine::Command> ptr_ftc(new engine::Finish_Turn_Command());
engine.addCommand(move(ptr_ftc), priority++);
cout << "FINISHING TURN" << endl;
fourround = false;
fiveround = true;
}
engine.update();
}
if (fiveround) {
engine.getState().setCurAction(IDLE);
p1X = engine.getState().getListCharacters(0)[0]->getPosition().getX();
p1Y = engine.getState().getListCharacters(0)[0]->getPosition().getY();
int priority = 0;
cout << "[Player 1] Character pos( " << engine.getState().getListCharacters(0)[0]->getPosition().getX()
<< " " << engine.getState().getListCharacters(0)[0]->getPosition().getY() << endl;
unique_ptr <engine::Command> ptr_sc(
new engine::Sel_Char_Command(*engine.getState().getListCharacters(0)[0]));
engine.addCommand(move(ptr_sc), priority++);
//cout<< "The First Plyaer Character has been Selected: Sel_Char_Command"<<endl;
engine.getState().setCurAction(ATTACKING);// Show the attack range
cout << "STATE IN ATTACING MODE: SHOW ATTACK RANGE" << endl;
unique_ptr <engine::Command> ptr_ac1(
new engine::Attack_Command(*engine.getState().getListCharacters(0)[0],
*engine.getState().getListCharacters(1)[0]));
engine.addCommand(move(ptr_ac1), priority++);
cout << "ATTACKED";
unique_ptr <engine::Command> ptr_ftc(new engine::Finish_Turn_Command());
engine.addCommand(move(ptr_ftc), priority++);
cout << "FINISHING TURN" << endl;
fiveround = false;
sixround = true;
engine.update();
}
if (sixround) {
engine.getState().setCurAction(IDLE);
//Player 2
p2X = engine.getState().getListCharacters(1)[0]->getPosition().getX();
p2Y = engine.getState().getListCharacters(1)[0]->getPosition().getY();
priority = 0;
cout << "[Player 2] Character pos( " << engine.getState().getListCharacters(1)[0]->getPosition().getX()
<< " " << engine.getState().getListCharacters(1)[0]->getPosition().getY() << endl;
unique_ptr <engine::Command> ptr_sc(
new engine::Sel_Char_Command(*engine.getState().getListCharacters(1)[0]));
engine.addCommand(move(ptr_sc), priority++);
//cout<< "The First Plyaer Character has been Selected: Sel_Char_Command"<<endl;
Position posTeleport{p2X - 2, p2Y - 2};
unique_ptr <engine::Command> ptr_cap(
new engine::Capab_Command(*engine.getState().getListCharacters(1)[0],
*engine.getState().getListCharacters(0)[0], posTeleport));
engine.addCommand(move(ptr_cap), priority++);
cout << "TELEPORTING" << endl;
usleep(1000000);
engine.getState().setCurAction(ATTACKING);// Show the attack range
cout << "STATE IN ATTACING MODE: SHOW ATTACK RANGE" << endl;
unique_ptr <engine::Command> ptr_ac2(
new engine::Attack_Command(*engine.getState().getListCharacters(1)[0],
*engine.getState().getListCharacters(0)[0]));
engine.addCommand(move(ptr_ac2), priority++);
cout << "ATTACKED";
unique_ptr <engine::Command> ptr_ftc(new engine::Finish_Turn_Command());
engine.addCommand(move(ptr_ftc), priority++);
cout << "FINISHING TURN" << endl;
sixround = false;
engine.update();
}
window.pollEvent(event);
if (event.type == sf::Event::Closed)
window.close();
}
}
} | 47.14 | 119 | 0.534366 | Kuga23 |
4b4a88a92eb5389cc24518a5e9e3e5b05e3510f6 | 423 | cc | C++ | src/ppl/nn/engines/x86/kernels/onnx/constant_kernel.cc | wolf15/ppl.nn | ac23e5eb518039536f1ef39b43c63d6bda900e77 | [
"Apache-2.0"
] | 1 | 2021-06-30T14:07:37.000Z | 2021-06-30T14:07:37.000Z | src/ppl/nn/engines/x86/kernels/onnx/constant_kernel.cc | wolf15/ppl.nn | ac23e5eb518039536f1ef39b43c63d6bda900e77 | [
"Apache-2.0"
] | null | null | null | src/ppl/nn/engines/x86/kernels/onnx/constant_kernel.cc | wolf15/ppl.nn | ac23e5eb518039536f1ef39b43c63d6bda900e77 | [
"Apache-2.0"
] | null | null | null | #include "ppl/nn/engines/x86/kernels/onnx/constant_kernel.h"
using namespace std;
using namespace ppl::common;
namespace ppl { namespace nn { namespace x86 {
RetCode ConstantKernel::DoExecute(KernelExecContext* ctx) {
auto output = ctx->GetOutput<TensorImpl>(0);
GetDevice()->CopyFromHost(&output->GetBufferDesc(), param_->data.data(), output->GetShape());
return RC_SUCCESS;
}
}}} // namespace ppl::nn::x86
| 30.214286 | 97 | 0.728132 | wolf15 |
4b4c4d4b90790b30be2c6ce0010ef3f8ab971bdb | 3,898 | cpp | C++ | devices/laihost/laihost.cpp | JartC0ding/horizon | 2b9a75b45ac768a8da0f7a98f164a37690dc583f | [
"MIT"
] | null | null | null | devices/laihost/laihost.cpp | JartC0ding/horizon | 2b9a75b45ac768a8da0f7a98f164a37690dc583f | [
"MIT"
] | null | null | null | devices/laihost/laihost.cpp | JartC0ding/horizon | 2b9a75b45ac768a8da0f7a98f164a37690dc583f | [
"MIT"
] | null | null | null | extern "C" {
#include <lai/host.h>
#include <acpispec/tables.h>
}
#include <memory/page_table_manager.h>
#include <memory/page_frame_allocator.h>
#include <utils/abort.h>
#include <utils/log.h>
#include <utils/string.h>
#include <utils/port.h>
#include <pci/pci.h>
#include <timer/timer.h>
#include <acpi/acpi.h>
extern "C" {
void* laihost_map(size_t address, size_t count) {
for (int i = 0; i < count / 0x1000; i++) {
memory::global_page_table_manager.map_memory((void*) (address + i * 0x1000), (void*) (address + i * 0x1000));
}
return (void*) address;
}
void laihost_unmap(void* pointer, size_t count) {
debugf("WARNING: laihost_unmap: %x %d not implemented!\n", pointer, count);
}
void laihost_log(int level, const char* msg) {
switch (level) {
case LAI_WARN_LOG:
debugf("WARNING: %s\n", msg);
break;
case LAI_DEBUG_LOG:
debugf("DEBUG: %s\n", msg);
break;
default:
debugf("UNKNOWN: %s\n", msg);
break;
}
}
__attribute__((noreturn)) void laihost_panic(const char* msg) {
abortf("laihost: %s\n", msg);
}
void* laihost_malloc(size_t size) {
return memory::global_allocator.request_pages(size / 0x1000 + 1);
}
void* laihost_realloc(void *oldptr, size_t newsize, size_t oldsize) {
if (newsize == 0) {
laihost_free(oldptr, oldsize);
return nullptr;
} else if (!oldptr) {
return laihost_malloc(newsize);
} else if (newsize <= oldsize) {
return oldptr;
} else {
void* newptr = laihost_malloc(newsize);
memcpy(newptr, oldptr, oldsize);
return newptr;
}
}
void laihost_free(void *ptr, size_t size) {
memory::global_allocator.free_pages(ptr, size / 0x1000 + 1);
}
void laihost_outb(uint16_t port, uint8_t val) {
outb(port, val);
}
void laihost_outw(uint16_t port, uint16_t val) {
outw(port, val);
}
void laihost_outd(uint16_t port, uint32_t val) {
outl(port, val);
}
uint8_t laihost_inb(uint16_t port) {
return inb(port);
}
uint16_t laihost_inw(uint16_t port) {
return inw(port);
}
uint32_t laihost_ind(uint16_t port) {
return inl(port);
}
void laihost_pci_writeb(uint16_t seg, uint8_t bus, uint8_t slot, uint8_t fun, uint16_t offset, uint8_t val) {
pci::pci_writeb(bus, slot, fun, offset, val);
}
void laihost_pci_writew(uint16_t seg, uint8_t bus, uint8_t slot, uint8_t fun, uint16_t offset, uint16_t val) {
pci::pci_writew(bus, slot, fun, offset, val);
}
void laihost_pci_writed(uint16_t seg, uint8_t bus, uint8_t slot, uint8_t fun, uint16_t offset, uint32_t val) {
pci::pci_writed(bus, slot, fun, offset, val);
}
uint8_t laihost_pci_readb(uint16_t seg, uint8_t bus, uint8_t slot, uint8_t fun, uint16_t offset) {
return pci::pci_readb(bus, slot, fun, offset);
}
uint16_t laihost_pci_readw(uint16_t seg, uint8_t bus, uint8_t slot, uint8_t fun, uint16_t offset) {
return pci::pci_readw(bus, slot, fun, offset);
}
uint32_t laihost_pci_readd(uint16_t seg, uint8_t bus, uint8_t slot, uint8_t fun, uint16_t offset) {
return pci::pci_readd(bus, slot, fun, offset);
}
void laihost_sleep(uint64_t ms) {
timer::global_timer->sleep(ms);
}
uint64_t laihost_timer(void) {
laihost_panic("laihost_timer not implemented! What is that even?");
}
void laihost_handle_amldebug(lai_variable_t* var) {
debugf("DEBUG: laihost_handle_amldebug with %x\n", var);
}
int laihost_sync_wait(struct lai_sync_state *sync, unsigned int val, int64_t timeout) {
debugf("WARNING: laihost_sync_wait not implemented!\n");
return -1;
}
void laihost_sync_wake(struct lai_sync_state *sync) {
debugf("WARNING: laihost_sync_wake not implemented!\n");
}
void* laihost_scan(const char *sig, size_t index) {
if (memcmp(sig, "DSDT", 4) == 0) {
return (void*) (uint64_t) ((acpi_fadt_t*) acpi::find_table(global_bootinfo, (char*) "FACP", 0))->dsdt;
} else {
return acpi::find_table(global_bootinfo, (char*) sig, index);
}
}
} | 26.161074 | 112 | 0.693689 | JartC0ding |
4b4d9667bcd8c48992dafb1598dcc5c44defc873 | 4,160 | cpp | C++ | example/Reading/source/main.cpp | HamletDuFromage/Simple-INI-Parser | ca427f98dc25620432430c563d9a73534b942c37 | [
"0BSD"
] | null | null | null | example/Reading/source/main.cpp | HamletDuFromage/Simple-INI-Parser | ca427f98dc25620432430c563d9a73534b942c37 | [
"0BSD"
] | null | null | null | example/Reading/source/main.cpp | HamletDuFromage/Simple-INI-Parser | ca427f98dc25620432430c563d9a73534b942c37 | [
"0BSD"
] | null | null | null | /*
* SimpleIniParser
* Copyright (c) 2020 Nichole Mattera
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <iostream>
#include <fstream>
#include <switch.h>
#include <SimpleIniParser.hpp>
#include <vector>
using namespace simpleIniParser;
void writeOption(IniOption * option, bool withTab) {
switch (option->type) {
case IniOptionType::SemicolonComment:
std::cout << ((withTab) ? "\t" : "") << "Type: Semicolon Comment, Value: \"" << option->value << "\"\n";
break;
case IniOptionType::HashtagComment:
std::cout << ((withTab) ? "\t" : "") << "Type: Hashtag Comment, Value: \"" << option->value << "\"\n";
break;
default:
std::cout << ((withTab) ? "\t" : "") << "Type: Option, Key: \"" << option->key << "\", Value: \"" << option->value << "\"\n";
break;
}
}
void writeSection(IniSection * section) {
switch (section->type) {
case IniSectionType::SemicolonComment:
std::cout << "Type: Semicolon Comment, Value: \"" << section->value << "\"\n";
break;
case IniSectionType::HashtagComment:
std::cout << "Type: Hashtag Comment, Value: \"" << section->value << "\"\n";
break;
case IniSectionType::HekateCaption:
std::cout << "Type: Hekate Caption, Value: \"" << section->value << "\"\n";
break;
default:
std::cout << "Type: Section, Value: \"" << section->value << "\"\n";
break;
}
for (auto const& option : section->options) {
writeOption(option, true);
}
std::cout << "\n";
}
int main(int argc, char **argv) {
consoleInit(NULL);
Result rc = romfsInit();
if (R_FAILED(rc)) {
std::cout << "Unable to initialize romfs.\n";
}
else {
Ini * config = Ini::parseFile("romfs:/config.ini");
std::cout << "Reading through an INI file.\n";
std::cout << "=====================================================\n\n";
for (auto const& option : config->options) {
writeOption(option, false);
}
if (config->options.size() > 0)
std::cout << "\n";
for (auto const& section : config->sections) {
writeSection(section);
}
std::cout << "\nGet a specific option from a specific section.\n";
std::cout << "=====================================================\n\n";
std::vector<IniOption *> options = config->findSection("CFW", true, IniSectionType::Section)->findAllOptions("logopath");
for (auto const& option : options) {
writeOption(option, false);
}
IniOption * option = config->findSection("config")->findFirstOption("cUsToMlOgO", false);
std::cout << "Key: \"" << option->key << "\" | Value: \"" << option->value << "\"\n";
IniOption * option2 = config->findSection("CFW", true, IniSectionType::Section)->findFirstOption("option comment test", false, IniOptionType::HashtagComment, IniOptionSearchField::Value);
std::cout << "Key: \"" << option2->key << "\" | Value: \"" << option2->value << "\"\n\n";
delete config;
}
std::cout << "\nPress any key to close.\n";
while(appletMainLoop())
{
hidScanInput();
if (hidKeysDown(CONTROLLER_P1_AUTO))
break;
consoleUpdate(NULL);
}
consoleExit(NULL);
return 0;
} | 33.821138 | 195 | 0.568029 | HamletDuFromage |
4b5209642cd837eb185a7620bf2c05692dbb57e3 | 62,359 | cpp | C++ | src/pal/src/map/virtual.cpp | chrisaut/coreclr | 849da1bdf828256624dac634eefe8590e48f0c26 | [
"MIT"
] | null | null | null | src/pal/src/map/virtual.cpp | chrisaut/coreclr | 849da1bdf828256624dac634eefe8590e48f0c26 | [
"MIT"
] | null | null | null | src/pal/src/map/virtual.cpp | chrisaut/coreclr | 849da1bdf828256624dac634eefe8590e48f0c26 | [
"MIT"
] | 1 | 2021-02-24T10:01:34.000Z | 2021-02-24T10:01:34.000Z | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
/*++
Module Name:
virtual.cpp
Abstract:
Implementation of virtual memory management functions.
--*/
#include "pal/thread.hpp"
#include "pal/cs.hpp"
#include "pal/malloc.hpp"
#include "pal/file.hpp"
#include "pal/seh.hpp"
#include "pal/dbgmsg.h"
#include "pal/virtual.h"
#include "pal/map.h"
#include "pal/init.h"
#include "common.h"
#include <sys/types.h>
#include <sys/mman.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#if HAVE_VM_ALLOCATE
#include <mach/vm_map.h>
#include <mach/mach_init.h>
#endif // HAVE_VM_ALLOCATE
using namespace CorUnix;
SET_DEFAULT_DEBUG_CHANNEL(VIRTUAL);
CRITICAL_SECTION virtual_critsec;
// The first node in our list of allocated blocks.
static PCMI pVirtualMemory;
/* We need MAP_ANON. However on some platforms like HP-UX, it is defined as MAP_ANONYMOUS */
#if !defined(MAP_ANON) && defined(MAP_ANONYMOUS)
#define MAP_ANON MAP_ANONYMOUS
#endif
/*++
Function:
ReserveVirtualMemory()
Helper function that is used by Virtual* APIs and ExecutableMemoryAllocator
to reserve virtual memory from the OS.
--*/
static LPVOID ReserveVirtualMemory(
IN CPalThread *pthrCurrent, /* Currently executing thread */
IN LPVOID lpAddress, /* Region to reserve or commit */
IN SIZE_T dwSize); /* Size of Region */
// A memory allocator that allocates memory from a pre-reserved region
// of virtual memory that is located near the CoreCLR library.
static ExecutableMemoryAllocator g_executableMemoryAllocator;
//
//
// Virtual Memory Logging
//
// We maintain a lightweight in-memory circular buffer recording virtual
// memory operations so that we can better diagnose failures and crashes
// caused by one of these operations mishandling memory in some way.
//
//
namespace VirtualMemoryLogging
{
// Specifies the operation being logged
enum class VirtualOperation
{
Allocate = 0x10,
Reserve = 0x20,
Commit = 0x30,
Decommit = 0x40,
Release = 0x50,
};
// Indicates that the attempted operation has failed
const DWORD FailedOperationMarker = 0x80000000;
// An entry in the in-memory log
struct LogRecord
{
LONG RecordId;
DWORD Operation;
LPVOID CurrentThread;
LPVOID RequestedAddress;
LPVOID ReturnedAddress;
SIZE_T Size;
DWORD AllocationType;
DWORD Protect;
};
// Maximum number of records in the in-memory log
const LONG MaxRecords = 128;
// Buffer used to store the logged data
volatile LogRecord logRecords[MaxRecords];
// Current record number. Use (recordNumber % MaxRecords) to determine
// the current position in the circular buffer.
volatile LONG recordNumber = 0;
// Record an entry in the in-memory log
void LogVaOperation(
IN VirtualOperation operation,
IN LPVOID requestedAddress,
IN SIZE_T size,
IN DWORD flAllocationType,
IN DWORD flProtect,
IN LPVOID returnedAddress,
IN BOOL result)
{
LONG i = InterlockedIncrement(&recordNumber) - 1;
LogRecord* curRec = (LogRecord*)&logRecords[i % MaxRecords];
curRec->RecordId = i;
curRec->CurrentThread = (LPVOID)pthread_self();
curRec->RequestedAddress = requestedAddress;
curRec->ReturnedAddress = returnedAddress;
curRec->Size = size;
curRec->AllocationType = flAllocationType;
curRec->Protect = flProtect;
curRec->Operation = static_cast<DWORD>(operation) | (result ? 0 : FailedOperationMarker);
}
}
/*++
Function:
VIRTUALInitialize()
Initializes this section's critical section.
Return value:
TRUE if initialization succeeded
FALSE otherwise.
--*/
extern "C"
BOOL
VIRTUALInitialize(bool initializeExecutableMemoryAllocator)
{
TRACE("Initializing the Virtual Critical Sections. \n");
InternalInitializeCriticalSection(&virtual_critsec);
pVirtualMemory = NULL;
if (initializeExecutableMemoryAllocator)
{
g_executableMemoryAllocator.Initialize();
}
return TRUE;
}
/***
*
* VIRTUALCleanup()
* Deletes this section's critical section.
*
*/
extern "C"
void VIRTUALCleanup()
{
PCMI pEntry;
PCMI pTempEntry;
CPalThread * pthrCurrent = InternalGetCurrentThread();
InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);
// Clean up the allocated memory.
pEntry = pVirtualMemory;
while ( pEntry )
{
WARN( "The memory at %d was not freed through a call to VirtualFree.\n",
pEntry->startBoundary );
free(pEntry->pAllocState);
free(pEntry->pProtectionState );
pTempEntry = pEntry;
pEntry = pEntry->pNext;
free(pTempEntry );
}
pVirtualMemory = NULL;
InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);
TRACE( "Deleting the Virtual Critical Sections. \n" );
DeleteCriticalSection( &virtual_critsec );
}
/***
*
* VIRTUALContainsInvalidProtectionFlags()
* Returns TRUE if an invalid flag is specified. FALSE otherwise.
*/
static BOOL VIRTUALContainsInvalidProtectionFlags( IN DWORD flProtect )
{
if ( ( flProtect & ~( PAGE_NOACCESS | PAGE_READONLY |
PAGE_READWRITE | PAGE_EXECUTE | PAGE_EXECUTE_READ |
PAGE_EXECUTE_READWRITE ) ) != 0 )
{
return TRUE;
}
else
{
return FALSE;
}
}
/****
*
* VIRTUALIsPageCommitted
*
* SIZE_T nBitToRetrieve - Which page to check.
*
* Returns TRUE if committed, FALSE otherwise.
*
*/
static BOOL VIRTUALIsPageCommitted( SIZE_T nBitToRetrieve, CONST PCMI pInformation )
{
SIZE_T nByteOffset = 0;
UINT nBitOffset = 0;
UINT byteMask = 0;
if ( !pInformation )
{
ERROR( "pInformation was NULL!\n" );
return FALSE;
}
nByteOffset = nBitToRetrieve / CHAR_BIT;
nBitOffset = nBitToRetrieve % CHAR_BIT;
byteMask = 1 << nBitOffset;
if ( pInformation->pAllocState[ nByteOffset ] & byteMask )
{
return TRUE;
}
else
{
return FALSE;
}
}
/*********
*
* VIRTUALGetAllocationType
*
* IN SIZE_T Index - The page within the range to retrieve
* the state for.
*
* IN pInformation - The virtual memory object.
*
*/
static INT VIRTUALGetAllocationType( SIZE_T Index, CONST PCMI pInformation )
{
if ( VIRTUALIsPageCommitted( Index, pInformation ) )
{
return MEM_COMMIT;
}
else
{
return MEM_RESERVE;
}
}
/****
*
* VIRTUALSetPageBits
*
* IN UINT nStatus - Bit set / reset [0: reset, any other value: set].
* IN SIZE_T nStartingBit - The bit to set.
*
* IN SIZE_T nNumberOfBits - The range of bits to set.
* IN BYTE* pBitArray - A pointer the array to be manipulated.
*
* Returns TRUE on success, FALSE otherwise.
* Turn on/off memory status bits.
*
*/
static BOOL VIRTUALSetPageBits ( UINT nStatus, SIZE_T nStartingBit,
SIZE_T nNumberOfBits, BYTE * pBitArray )
{
/* byte masks for optimized modification of partial bytes (changing less
than 8 bits in a single byte). note that bits are treated in little
endian order : value 1 is bit 0; value 128 is bit 7. in the binary
representations below, bit 0 is on the right */
/* start masks : for modifying bits >= n while preserving bits < n.
example : if nStartignBit%8 is 3, then bits 0, 1, 2 remain unchanged
while bits 3..7 are changed; startmasks[3] can be used for this. */
static const BYTE startmasks[8] = {
0xff, /* start at 0 : 1111 1111 */
0xfe, /* start at 1 : 1111 1110 */
0xfc, /* start at 2 : 1111 1100 */
0xf8, /* start at 3 : 1111 1000 */
0xf0, /* start at 4 : 1111 0000 */
0xe0, /* start at 5 : 1110 0000 */
0xc0, /* start at 6 : 1100 0000 */
0x80 /* start at 7 : 1000 0000 */
};
/* end masks : for modifying bits <= n while preserving bits > n.
example : if the last bit to change is 5, then bits 6 & 7 stay unchanged
while bits 1..5 are changed; endmasks[5] can be used for this. */
static const BYTE endmasks[8] = {
0x01, /* end at 0 : 0000 0001 */
0x03, /* end at 1 : 0000 0011 */
0x07, /* end at 2 : 0000 0111 */
0x0f, /* end at 3 : 0000 1111 */
0x1f, /* end at 4 : 0001 1111 */
0x3f, /* end at 5 : 0011 1111 */
0x7f, /* end at 6 : 0111 1111 */
0xff /* end at 7 : 1111 1111 */
};
/* last example : if only the middle of a byte must be changed, both start
and end masks can be combined (bitwise AND) to obtain the correct mask.
if we want to change bits 2 to 4 :
startmasks[2] : 0xfc 1111 1100 (change 2,3,4,5,6,7)
endmasks[4]: 0x1f 0001 1111 (change 0,1,2,3,4)
bitwise AND : 0x1c 0001 1100 (change 2,3,4)
*/
BYTE byte_mask;
SIZE_T nLastBit;
SIZE_T nFirstByte;
SIZE_T nLastByte;
SIZE_T nFullBytes;
TRACE( "VIRTUALSetPageBits( nStatus = %d, nStartingBit = %d, "
"nNumberOfBits = %d, pBitArray = 0x%p )\n",
nStatus, nStartingBit, nNumberOfBits, pBitArray );
if ( 0 == nNumberOfBits )
{
ERROR( "nNumberOfBits was 0!\n" );
return FALSE;
}
nLastBit = nStartingBit+nNumberOfBits-1;
nFirstByte = nStartingBit / 8;
nLastByte = nLastBit / 8;
/* handle partial first byte (if any) */
if(0 != (nStartingBit % 8))
{
byte_mask = startmasks[nStartingBit % 8];
/* if 1st byte is the only changing byte, combine endmask to preserve
trailing bits (see 3rd example above) */
if( nLastByte == nFirstByte)
{
byte_mask &= endmasks[nLastBit % 8];
}
/* byte_mask contains 1 for bits to change, 0 for bits to leave alone */
if(0 == nStatus)
{
/* bits to change must be set to 0 : invert byte_mask (giving 0 for
bits to change), use bitwise AND */
pBitArray[nFirstByte] &= ~byte_mask;
}
else
{
/* bits to change must be set to 1 : use bitwise OR */
pBitArray[nFirstByte] |= byte_mask;
}
/* stop right away if only 1 byte is being modified */
if(nLastByte == nFirstByte)
{
return TRUE;
}
/* we're done with the 1st byte; skip over it */
nFirstByte++;
}
/* number of bytes to change, excluding the last byte (handled separately)*/
nFullBytes = nLastByte - nFirstByte;
if(0 != nFullBytes)
{
// Turn off/on dirty bits
memset( &(pBitArray[nFirstByte]), (0 == nStatus) ? 0 : 0xFF, nFullBytes );
}
/* handle last (possibly partial) byte */
byte_mask = endmasks[nLastBit % 8];
/* byte_mask contains 1 for bits to change, 0 for bits to leave alone */
if(0 == nStatus)
{
/* bits to change must be set to 0 : invert byte_mask (giving 0 for
bits to change), use bitwise AND */
pBitArray[nLastByte] &= ~byte_mask;
}
else
{
/* bits to change must be set to 1 : use bitwise OR */
pBitArray[nLastByte] |= byte_mask;
}
return TRUE;
}
/****
*
* VIRTUALSetAllocState
*
* IN UINT nAction - Which action to perform.
* IN SIZE_T nStartingBit - The bit to set.
*
* IN SIZE_T nNumberOfBits - The range of bits to set.
* IN PCMI pStateArray - A pointer the array to be manipulated.
*
* Returns TRUE on success, FALSE otherwise.
* Turn bit on to indicate committed, turn bit off to indicate reserved.
*
*/
static BOOL VIRTUALSetAllocState( UINT nAction, SIZE_T nStartingBit,
SIZE_T nNumberOfBits, CONST PCMI pInformation )
{
TRACE( "VIRTUALSetAllocState( nAction = %d, nStartingBit = %d, "
"nNumberOfBits = %d, pStateArray = 0x%p )\n",
nAction, nStartingBit, nNumberOfBits, pInformation );
if ( !pInformation )
{
ERROR( "pInformation was invalid!\n" );
return FALSE;
}
return VIRTUALSetPageBits((MEM_COMMIT == nAction) ? 1 : 0, nStartingBit,
nNumberOfBits, pInformation->pAllocState);
}
/****
*
* VIRTUALFindRegionInformation( )
*
* IN UINT_PTR address - The address to look for.
*
* Returns the PCMI if found, NULL otherwise.
*/
static PCMI VIRTUALFindRegionInformation( IN UINT_PTR address )
{
PCMI pEntry = NULL;
TRACE( "VIRTUALFindRegionInformation( %#x )\n", address );
pEntry = pVirtualMemory;
while( pEntry )
{
if ( pEntry->startBoundary > address )
{
/* Gone past the possible location in the list. */
pEntry = NULL;
break;
}
if ( pEntry->startBoundary + pEntry->memSize > address )
{
break;
}
pEntry = pEntry->pNext;
}
return pEntry;
}
/*++
Function :
VIRTUALReleaseMemory
Removes a PCMI entry from the list.
Returns true on success. FALSE otherwise.
--*/
static BOOL VIRTUALReleaseMemory( PCMI pMemoryToBeReleased )
{
BOOL bRetVal = TRUE;
if ( !pMemoryToBeReleased )
{
ASSERT( "Invalid pointer.\n" );
return FALSE;
}
if ( pMemoryToBeReleased == pVirtualMemory )
{
/* This is either the first entry, or the only entry. */
pVirtualMemory = pMemoryToBeReleased->pNext;
if ( pMemoryToBeReleased->pNext )
{
pMemoryToBeReleased->pNext->pPrevious = NULL;
}
}
else /* Could be anywhere in the list. */
{
/* Delete the entry from the linked list. */
if ( pMemoryToBeReleased->pPrevious )
{
pMemoryToBeReleased->pPrevious->pNext = pMemoryToBeReleased->pNext;
}
if ( pMemoryToBeReleased->pNext )
{
pMemoryToBeReleased->pNext->pPrevious = pMemoryToBeReleased->pPrevious;
}
}
free( pMemoryToBeReleased->pAllocState );
pMemoryToBeReleased->pAllocState = NULL;
free( pMemoryToBeReleased->pProtectionState );
pMemoryToBeReleased->pProtectionState = NULL;
free( pMemoryToBeReleased );
pMemoryToBeReleased = NULL;
return bRetVal;
}
/****
* VIRTUALConvertWinFlags() -
* Converts win32 protection flags to
* internal VIRTUAL flags.
*
*/
static BYTE VIRTUALConvertWinFlags( IN DWORD flProtect )
{
BYTE MemAccessControl = 0;
switch ( flProtect & 0xff )
{
case PAGE_NOACCESS :
MemAccessControl = VIRTUAL_NOACCESS;
break;
case PAGE_READONLY :
MemAccessControl = VIRTUAL_READONLY;
break;
case PAGE_READWRITE :
MemAccessControl = VIRTUAL_READWRITE;
break;
case PAGE_EXECUTE :
MemAccessControl = VIRTUAL_EXECUTE;
break;
case PAGE_EXECUTE_READ :
MemAccessControl = VIRTUAL_EXECUTE_READ;
break;
case PAGE_EXECUTE_READWRITE:
MemAccessControl = VIRTUAL_EXECUTE_READWRITE;
break;
default :
MemAccessControl = 0;
ERROR( "Incorrect or no protection flags specified.\n" );
break;
}
return MemAccessControl;
}
/****
* VIRTUALConvertVirtualFlags() -
* Converts internal virtual protection
* flags to their win32 counterparts.
*/
static DWORD VIRTUALConvertVirtualFlags( IN BYTE VirtualProtect )
{
DWORD MemAccessControl = 0;
if ( VirtualProtect == VIRTUAL_READONLY )
{
MemAccessControl = PAGE_READONLY;
}
else if ( VirtualProtect == VIRTUAL_READWRITE )
{
MemAccessControl = PAGE_READWRITE;
}
else if ( VirtualProtect == VIRTUAL_EXECUTE_READWRITE )
{
MemAccessControl = PAGE_EXECUTE_READWRITE;
}
else if ( VirtualProtect == VIRTUAL_EXECUTE_READ )
{
MemAccessControl = PAGE_EXECUTE_READ;
}
else if ( VirtualProtect == VIRTUAL_EXECUTE )
{
MemAccessControl = PAGE_EXECUTE;
}
else if ( VirtualProtect == VIRTUAL_NOACCESS )
{
MemAccessControl = PAGE_NOACCESS;
}
else
{
MemAccessControl = 0;
ERROR( "Incorrect or no protection flags specified.\n" );
}
return MemAccessControl;
}
/***
* Displays the linked list.
*
*/
#if defined _DEBUG
static void VIRTUALDisplayList( void )
{
if (!DBG_ENABLED(DLI_TRACE, defdbgchan))
return;
PCMI p;
SIZE_T count;
SIZE_T index;
CPalThread * pthrCurrent = InternalGetCurrentThread();
InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);
p = pVirtualMemory;
count = 0;
while ( p ) {
DBGOUT( "Entry %d : \n", count );
DBGOUT( "\t startBoundary %#x \n", p->startBoundary );
DBGOUT( "\t memSize %d \n", p->memSize );
DBGOUT( "\t pAllocState " );
for ( index = 0; index < p->memSize / VIRTUAL_PAGE_SIZE; index++)
{
DBGOUT( "[%d] ", VIRTUALGetAllocationType( index, p ) );
}
DBGOUT( "\t pProtectionState " );
for ( index = 0; index < p->memSize / VIRTUAL_PAGE_SIZE; index++ )
{
DBGOUT( "[%d] ", (UINT)p->pProtectionState[ index ] );
}
DBGOUT( "\n" );
DBGOUT( "\t accessProtection %d \n", p->accessProtection );
DBGOUT( "\t allocationType %d \n", p->allocationType );
DBGOUT( "\t pNext %p \n", p->pNext );
DBGOUT( "\t pLast %p \n", p->pPrevious );
count++;
p = p->pNext;
}
InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);
}
#endif
#ifdef DEBUG
void VerifyRightEntry(PCMI pEntry)
{
volatile PCMI pRight = pEntry->pNext;
SIZE_T endAddress;
if (pRight != nullptr)
{
endAddress = ((SIZE_T)pEntry->startBoundary) + pEntry->memSize;
_ASSERTE(endAddress <= (SIZE_T)pRight->startBoundary);
}
}
void VerifyLeftEntry(PCMI pEntry)
{
volatile PCMI pLeft = pEntry->pPrevious;
SIZE_T endAddress;
if (pLeft != NULL)
{
endAddress = ((SIZE_T)pLeft->startBoundary) + pLeft->memSize;
_ASSERTE(endAddress <= (SIZE_T)pEntry->startBoundary);
}
}
#endif // DEBUG
/****
* VIRTUALStoreAllocationInfo()
*
* Stores the allocation information in the linked list.
* NOTE: The caller must own the critical section.
*/
static BOOL VIRTUALStoreAllocationInfo(
IN UINT_PTR startBoundary, /* Start of the region. */
IN SIZE_T memSize, /* Size of the region. */
IN DWORD flAllocationType, /* Allocation Types. */
IN DWORD flProtection ) /* Protections flags on the memory. */
{
PCMI pNewEntry = nullptr;
PCMI pMemInfo = nullptr;
SIZE_T nBufferSize = 0;
if ((memSize & VIRTUAL_PAGE_MASK) != 0)
{
ERROR("The memory size was not a multiple of the page size. \n");
return FALSE;
}
if (!(pNewEntry = (PCMI)InternalMalloc(sizeof(*pNewEntry))))
{
ERROR( "Unable to allocate memory for the structure.\n");
return FALSE;
}
pNewEntry->startBoundary = startBoundary;
pNewEntry->memSize = memSize;
pNewEntry->allocationType = flAllocationType;
pNewEntry->accessProtection = flProtection;
nBufferSize = memSize / VIRTUAL_PAGE_SIZE / CHAR_BIT;
if ((memSize / VIRTUAL_PAGE_SIZE) % CHAR_BIT != 0)
{
nBufferSize++;
}
pNewEntry->pAllocState = (BYTE*)InternalMalloc(nBufferSize);
pNewEntry->pProtectionState = (BYTE*)InternalMalloc((memSize / VIRTUAL_PAGE_SIZE));
if (pNewEntry->pAllocState && pNewEntry->pProtectionState)
{
/* Set the intial allocation state, and initial allocation protection. */
VIRTUALSetAllocState(MEM_RESERVE, 0, nBufferSize * CHAR_BIT, pNewEntry);
memset(pNewEntry->pProtectionState,
VIRTUALConvertWinFlags(flProtection),
memSize / VIRTUAL_PAGE_SIZE);
}
else
{
ERROR( "Unable to allocate memory for the structure.\n");
if (pNewEntry->pProtectionState) free(pNewEntry->pProtectionState);
pNewEntry->pProtectionState = nullptr;
if (pNewEntry->pAllocState) free(pNewEntry->pAllocState);
pNewEntry->pAllocState = nullptr;
free(pNewEntry);
pNewEntry = nullptr;
return FALSE;
}
pMemInfo = pVirtualMemory;
if (pMemInfo && pMemInfo->startBoundary < startBoundary)
{
/* Look for the correct insert point */
TRACE("Looking for the correct insert location.\n");
while (pMemInfo->pNext && (pMemInfo->pNext->startBoundary < startBoundary))
{
pMemInfo = pMemInfo->pNext;
}
pNewEntry->pNext = pMemInfo->pNext;
pNewEntry->pPrevious = pMemInfo;
if (pNewEntry->pNext)
{
pNewEntry->pNext->pPrevious = pNewEntry;
}
pMemInfo->pNext = pNewEntry;
}
else
{
/* This is the first entry in the list. */
pNewEntry->pNext = pMemInfo;
pNewEntry->pPrevious = nullptr;
if (pNewEntry->pNext)
{
pNewEntry->pNext->pPrevious = pNewEntry;
}
pVirtualMemory = pNewEntry ;
}
#ifdef DEBUG
VerifyRightEntry(pNewEntry);
VerifyLeftEntry(pNewEntry);
#endif // DEBUG
return TRUE;
}
/******
*
* VIRTUALReserveMemory() - Helper function that actually reserves the memory.
*
* NOTE: I call SetLastError in here, because many different error states
* exists, and that would be very complicated to work around.
*
*/
static LPVOID VIRTUALReserveMemory(
IN CPalThread *pthrCurrent, /* Currently executing thread */
IN LPVOID lpAddress, /* Region to reserve or commit */
IN SIZE_T dwSize, /* Size of Region */
IN DWORD flAllocationType, /* Type of allocation */
IN DWORD flProtect) /* Type of access protection */
{
LPVOID pRetVal = NULL;
UINT_PTR StartBoundary;
SIZE_T MemSize;
TRACE( "Reserving the memory now..\n");
// First, figure out where we're trying to reserve the memory and
// how much we need. On most systems, requests to mmap must be
// page-aligned and at multiples of the page size.
StartBoundary = (UINT_PTR)lpAddress & ~BOUNDARY_64K;
/* Add the sizes, and round down to the nearest page boundary. */
MemSize = ( ((UINT_PTR)lpAddress + dwSize + VIRTUAL_PAGE_MASK) & ~VIRTUAL_PAGE_MASK ) -
StartBoundary;
InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);
// If this is a request for special executable (JIT'ed) memory then, first of all,
// try to get memory from the executable memory allocator to satisfy the request.
if (((flAllocationType & MEM_RESERVE_EXECUTABLE) != 0) && (lpAddress == NULL))
{
pRetVal = g_executableMemoryAllocator.AllocateMemory(MemSize);
}
if (pRetVal == NULL)
{
// Try to reserve memory from the OS
pRetVal = ReserveVirtualMemory(pthrCurrent, (LPVOID)StartBoundary, MemSize);
}
if (pRetVal != NULL)
{
if ( !lpAddress )
{
/* Compute the real values instead of the null values. */
StartBoundary = (UINT_PTR)pRetVal & ~VIRTUAL_PAGE_MASK;
MemSize = ( ((UINT_PTR)pRetVal + dwSize + VIRTUAL_PAGE_MASK) & ~VIRTUAL_PAGE_MASK ) -
StartBoundary;
}
if ( !VIRTUALStoreAllocationInfo( StartBoundary, MemSize,
flAllocationType, flProtect ) )
{
ASSERT( "Unable to store the structure in the list.\n");
pthrCurrent->SetLastError( ERROR_INTERNAL_ERROR );
munmap( pRetVal, MemSize );
pRetVal = NULL;
}
}
LogVaOperation(
VirtualMemoryLogging::VirtualOperation::Reserve,
lpAddress,
dwSize,
flAllocationType,
flProtect,
pRetVal,
pRetVal != NULL);
InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);
return pRetVal;
}
/******
*
* ReserveVirtualMemory() - Helper function that is used by Virtual* APIs
* and ExecutableMemoryAllocator to reserve virtual memory from the OS.
*
*/
static LPVOID ReserveVirtualMemory(
IN CPalThread *pthrCurrent, /* Currently executing thread */
IN LPVOID lpAddress, /* Region to reserve or commit */
IN SIZE_T dwSize) /* Size of Region */
{
UINT_PTR StartBoundary = (UINT_PTR)lpAddress;
SIZE_T MemSize = dwSize;
TRACE( "Reserving the memory now.\n");
// Most platforms will only commit memory if it is dirtied,
// so this should not consume too much swap space.
int mmapFlags = 0;
#if HAVE_VM_ALLOCATE
// Allocate with vm_allocate first, then map at the fixed address.
int result = vm_allocate(mach_task_self(),
&StartBoundary,
MemSize,
((LPVOID) StartBoundary != nullptr) ? FALSE : TRUE);
if (result != KERN_SUCCESS)
{
ERROR("vm_allocate failed to allocated the requested region!\n");
pthrCurrent->SetLastError(ERROR_INVALID_ADDRESS);
return nullptr;
}
mmapFlags |= MAP_FIXED;
#endif // HAVE_VM_ALLOCATE
mmapFlags |= MAP_ANON | MAP_PRIVATE;
LPVOID pRetVal = mmap((LPVOID) StartBoundary,
MemSize,
PROT_NONE,
mmapFlags,
-1 /* fd */,
0 /* offset */);
if (pRetVal == MAP_FAILED)
{
ERROR( "Failed due to insufficient memory.\n" );
#if HAVE_VM_ALLOCATE
vm_deallocate(mach_task_self(), StartBoundary, MemSize);
#endif // HAVE_VM_ALLOCATE
pthrCurrent->SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return nullptr;
}
/* Check to see if the region is what we asked for. */
if (lpAddress != nullptr && StartBoundary != (UINT_PTR)pRetVal)
{
ERROR("We did not get the region we asked for from mmap!\n");
pthrCurrent->SetLastError(ERROR_INVALID_ADDRESS);
munmap(pRetVal, MemSize);
return nullptr;
}
#if MMAP_ANON_IGNORES_PROTECTION
if (mprotect(pRetVal, MemSize, PROT_NONE) != 0)
{
ERROR("mprotect failed to protect the region!\n");
pthrCurrent->SetLastError(ERROR_INVALID_ADDRESS);
munmap(pRetVal, MemSize);
return nullptr;
}
#endif // MMAP_ANON_IGNORES_PROTECTION
return pRetVal;
}
/******
*
* VIRTUALCommitMemory() - Helper function that actually commits the memory.
*
* NOTE: I call SetLastError in here, because many different error states
* exists, and that would be very complicated to work around.
*
*/
static LPVOID
VIRTUALCommitMemory(
IN CPalThread *pthrCurrent, /* Currently executing thread */
IN LPVOID lpAddress, /* Region to reserve or commit */
IN SIZE_T dwSize, /* Size of Region */
IN DWORD flAllocationType, /* Type of allocation */
IN DWORD flProtect) /* Type of access protection */
{
UINT_PTR StartBoundary = 0;
SIZE_T MemSize = 0;
PCMI pInformation = 0;
LPVOID pRetVal = NULL;
BOOL IsLocallyReserved = FALSE;
SIZE_T totalPages;
INT allocationType, curAllocationType;
INT protectionState, curProtectionState;
SIZE_T initialRunStart;
SIZE_T runStart;
SIZE_T runLength;
SIZE_T index;
INT nProtect;
INT vProtect;
if ( lpAddress )
{
StartBoundary = (UINT_PTR)lpAddress & ~VIRTUAL_PAGE_MASK;
/* Add the sizes, and round down to the nearest page boundary. */
MemSize = ( ((UINT_PTR)lpAddress + dwSize + VIRTUAL_PAGE_MASK) & ~VIRTUAL_PAGE_MASK ) -
StartBoundary;
}
else
{
MemSize = ( dwSize + VIRTUAL_PAGE_MASK ) & ~VIRTUAL_PAGE_MASK;
}
/* See if we have already reserved this memory. */
pInformation = VIRTUALFindRegionInformation( StartBoundary );
if ( !pInformation )
{
/* According to the new MSDN docs, if MEM_COMMIT is specified,
and the memory is not reserved, you reserve and then commit.
*/
LPVOID pReservedMemory =
VIRTUALReserveMemory( pthrCurrent, lpAddress, dwSize,
flAllocationType, flProtect );
TRACE( "Reserve and commit the memory!\n " );
if ( pReservedMemory )
{
/* Re-align the addresses and try again to find the memory. */
StartBoundary = (UINT_PTR)pReservedMemory & ~VIRTUAL_PAGE_MASK;
MemSize = ( ((UINT_PTR)pReservedMemory + dwSize + VIRTUAL_PAGE_MASK)
& ~VIRTUAL_PAGE_MASK ) - StartBoundary;
pInformation = VIRTUALFindRegionInformation( StartBoundary );
if ( !pInformation )
{
ASSERT( "Unable to locate the region information.\n" );
pthrCurrent->SetLastError( ERROR_INTERNAL_ERROR );
pRetVal = NULL;
goto done;
}
IsLocallyReserved = TRUE;
}
else
{
ERROR( "Unable to reserve the memory.\n" );
/* Don't set last error here, it will already be set. */
pRetVal = NULL;
goto done;
}
}
TRACE( "Committing the memory now..\n");
// Pages that aren't already committed need to be committed. Pages that
// are committed don't need to be committed, but they might need to have
// their permissions changed.
// To get this right, we find runs of pages with similar states and
// permissions. If a run is not committed, we commit it and then set
// its permissions. If a run is committed but has different permissions
// from what we're trying to set, we set its permissions. Finally,
// if a run is already committed and has the right permissions,
// we don't need to do anything to it.
totalPages = MemSize / VIRTUAL_PAGE_SIZE;
runStart = (StartBoundary - pInformation->startBoundary) /
VIRTUAL_PAGE_SIZE; // Page index
initialRunStart = runStart;
allocationType = VIRTUALGetAllocationType(runStart, pInformation);
protectionState = pInformation->pProtectionState[runStart];
curAllocationType = allocationType;
curProtectionState = protectionState;
runLength = 1;
nProtect = W32toUnixAccessControl(flProtect);
vProtect = VIRTUALConvertWinFlags(flProtect);
if (totalPages > pInformation->memSize / VIRTUAL_PAGE_SIZE - runStart)
{
ERROR("Trying to commit beyond the end of the region!\n");
goto error;
}
while(runStart < initialRunStart + totalPages)
{
// Find the next run of pages
for(index = runStart + 1; index < initialRunStart + totalPages;
index++)
{
curAllocationType = VIRTUALGetAllocationType(index, pInformation);
curProtectionState = pInformation->pProtectionState[index];
if (curAllocationType != allocationType ||
curProtectionState != protectionState)
{
break;
}
runLength++;
}
StartBoundary = pInformation->startBoundary + runStart * VIRTUAL_PAGE_SIZE;
MemSize = runLength * VIRTUAL_PAGE_SIZE;
if (allocationType != MEM_COMMIT)
{
// Commit the pages
if (mprotect((void *) StartBoundary, MemSize, PROT_WRITE | PROT_READ) != 0)
{
ERROR("mprotect() failed! Error(%d)=%s\n", errno, strerror(errno));
goto error;
}
VIRTUALSetAllocState(MEM_COMMIT, runStart, runLength, pInformation);
if (nProtect == (PROT_WRITE | PROT_READ))
{
// Handle this case specially so we don't bother
// mprotect'ing the region.
memset(pInformation->pProtectionState + runStart,
vProtect, runLength);
}
protectionState = VIRTUAL_READWRITE;
}
if (protectionState != vProtect)
{
// Change permissions.
if (mprotect((void *) StartBoundary, MemSize, nProtect) != -1)
{
memset(pInformation->pProtectionState + runStart,
vProtect, runLength);
}
else
{
ERROR("mprotect() failed! Error(%d)=%s\n",
errno, strerror(errno));
goto error;
}
}
runStart = index;
runLength = 1;
allocationType = curAllocationType;
protectionState = curProtectionState;
}
pRetVal = (void *) (pInformation->startBoundary + initialRunStart * VIRTUAL_PAGE_SIZE);
goto done;
error:
if ( flAllocationType & MEM_RESERVE || IsLocallyReserved )
{
munmap( pRetVal, MemSize );
if ( VIRTUALReleaseMemory( pInformation ) == FALSE )
{
ASSERT( "Unable to remove the PCMI entry from the list.\n" );
pthrCurrent->SetLastError( ERROR_INTERNAL_ERROR );
pRetVal = NULL;
goto done;
}
pInformation = NULL;
pRetVal = NULL;
}
done:
LogVaOperation(
VirtualMemoryLogging::VirtualOperation::Commit,
lpAddress,
dwSize,
flAllocationType,
flProtect,
pRetVal,
pRetVal != NULL);
return pRetVal;
}
/*++
Function:
VirtualAlloc
Note:
MEM_TOP_DOWN, MEM_PHYSICAL, MEM_WRITE_WATCH are not supported.
Unsupported flags are ignored.
Page size on i386 is set to 4k.
See MSDN doc.
--*/
LPVOID
PALAPI
VirtualAlloc(
IN LPVOID lpAddress, /* Region to reserve or commit */
IN SIZE_T dwSize, /* Size of Region */
IN DWORD flAllocationType, /* Type of allocation */
IN DWORD flProtect) /* Type of access protection */
{
LPVOID pRetVal = NULL;
CPalThread *pthrCurrent;
PERF_ENTRY(VirtualAlloc);
ENTRY("VirtualAlloc(lpAddress=%p, dwSize=%u, flAllocationType=%#x, \
flProtect=%#x)\n", lpAddress, dwSize, flAllocationType, flProtect);
pthrCurrent = InternalGetCurrentThread();
if ( ( flAllocationType & MEM_WRITE_WATCH ) != 0 )
{
pthrCurrent->SetLastError( ERROR_INVALID_PARAMETER );
goto done;
}
/* Test for un-supported flags. */
if ( ( flAllocationType & ~( MEM_COMMIT | MEM_RESERVE | MEM_TOP_DOWN | MEM_RESERVE_EXECUTABLE ) ) != 0 )
{
ASSERT( "flAllocationType can be one, or any combination of MEM_COMMIT, \
MEM_RESERVE, MEM_TOP_DOWN, or MEM_RESERVE_EXECUTABLE.\n" );
pthrCurrent->SetLastError( ERROR_INVALID_PARAMETER );
goto done;
}
if ( VIRTUALContainsInvalidProtectionFlags( flProtect ) )
{
ASSERT( "flProtect can be one of PAGE_READONLY, PAGE_READWRITE, or \
PAGE_EXECUTE_READWRITE || PAGE_NOACCESS. \n" );
pthrCurrent->SetLastError( ERROR_INVALID_PARAMETER );
goto done;
}
if ( flAllocationType & MEM_TOP_DOWN )
{
WARN( "Ignoring the allocation flag MEM_TOP_DOWN.\n" );
}
LogVaOperation(
VirtualMemoryLogging::VirtualOperation::Allocate,
lpAddress,
dwSize,
flAllocationType,
flProtect,
NULL,
TRUE);
if ( flAllocationType & MEM_RESERVE )
{
InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);
pRetVal = VIRTUALReserveMemory( pthrCurrent, lpAddress, dwSize, flAllocationType, flProtect );
InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);
if ( !pRetVal )
{
/* Error messages are already displayed, just leave. */
goto done;
}
}
if ( flAllocationType & MEM_COMMIT )
{
InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);
if ( pRetVal != NULL )
{
/* We are reserving and committing. */
pRetVal = VIRTUALCommitMemory( pthrCurrent, pRetVal, dwSize,
flAllocationType, flProtect );
}
else
{
/* Just a commit. */
pRetVal = VIRTUALCommitMemory( pthrCurrent, lpAddress, dwSize,
flAllocationType, flProtect );
}
InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);
}
done:
#if defined _DEBUG
VIRTUALDisplayList();
#endif
LOGEXIT("VirtualAlloc returning %p\n ", pRetVal );
PERF_EXIT(VirtualAlloc);
return pRetVal;
}
/*++
Function:
VirtualFree
See MSDN doc.
--*/
BOOL
PALAPI
VirtualFree(
IN LPVOID lpAddress, /* Address of region. */
IN SIZE_T dwSize, /* Size of region. */
IN DWORD dwFreeType ) /* Operation type. */
{
BOOL bRetVal = TRUE;
CPalThread *pthrCurrent;
PERF_ENTRY(VirtualFree);
ENTRY("VirtualFree(lpAddress=%p, dwSize=%u, dwFreeType=%#x)\n",
lpAddress, dwSize, dwFreeType);
pthrCurrent = InternalGetCurrentThread();
InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);
/* Sanity Checks. */
if ( !lpAddress )
{
ERROR( "lpAddress cannot be NULL. You must specify the base address of\
regions to be de-committed. \n" );
pthrCurrent->SetLastError( ERROR_INVALID_ADDRESS );
bRetVal = FALSE;
goto VirtualFreeExit;
}
if ( !( dwFreeType & MEM_RELEASE ) && !(dwFreeType & MEM_DECOMMIT ) )
{
ERROR( "dwFreeType must contain one of the following: \
MEM_RELEASE or MEM_DECOMMIT\n" );
pthrCurrent->SetLastError( ERROR_INVALID_PARAMETER );
bRetVal = FALSE;
goto VirtualFreeExit;
}
/* You cannot release and decommit in one call.*/
if ( dwFreeType & MEM_RELEASE && dwFreeType & MEM_DECOMMIT )
{
ERROR( "MEM_RELEASE cannot be combined with MEM_DECOMMIT.\n" );
bRetVal = FALSE;
goto VirtualFreeExit;
}
if ( dwFreeType & MEM_DECOMMIT )
{
UINT_PTR StartBoundary = 0;
SIZE_T MemSize = 0;
if ( dwSize == 0 )
{
ERROR( "dwSize cannot be 0. \n" );
pthrCurrent->SetLastError( ERROR_INVALID_PARAMETER );
bRetVal = FALSE;
goto VirtualFreeExit;
}
/*
* A two byte range straddling 2 pages caues both pages to be either
* released or decommitted. So round the dwSize up to the next page
* boundary and round the lpAddress down to the next page boundary.
*/
MemSize = (((UINT_PTR)(dwSize) + ((UINT_PTR)(lpAddress) & VIRTUAL_PAGE_MASK)
+ VIRTUAL_PAGE_MASK) & ~VIRTUAL_PAGE_MASK);
StartBoundary = (UINT_PTR)lpAddress & ~VIRTUAL_PAGE_MASK;
PCMI pUnCommittedMem;
pUnCommittedMem = VIRTUALFindRegionInformation( StartBoundary );
if (!pUnCommittedMem)
{
ASSERT( "Unable to locate the region information.\n" );
pthrCurrent->SetLastError( ERROR_INTERNAL_ERROR );
bRetVal = FALSE;
goto VirtualFreeExit;
}
TRACE( "Un-committing the following page(s) %d to %d.\n",
StartBoundary, MemSize );
// Explicitly calling mmap instead of mprotect here makes it
// that much more clear to the operating system that we no
// longer need these pages.
if ( mmap( (LPVOID)StartBoundary, MemSize, PROT_NONE,
MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0 ) != MAP_FAILED )
{
#if (MMAP_ANON_IGNORES_PROTECTION)
if (mprotect((LPVOID) StartBoundary, MemSize, PROT_NONE) != 0)
{
ASSERT("mprotect failed to protect the region!\n");
pthrCurrent->SetLastError(ERROR_INTERNAL_ERROR);
munmap((LPVOID) StartBoundary, MemSize);
bRetVal = FALSE;
goto VirtualFreeExit;
}
#endif // MMAP_ANON_IGNORES_PROTECTION
SIZE_T index = 0;
SIZE_T nNumOfPagesToChange = 0;
/* We can now commit this memory by calling VirtualAlloc().*/
index = (StartBoundary - pUnCommittedMem->startBoundary) / VIRTUAL_PAGE_SIZE;
nNumOfPagesToChange = MemSize / VIRTUAL_PAGE_SIZE;
VIRTUALSetAllocState( MEM_RESERVE, index,
nNumOfPagesToChange, pUnCommittedMem );
goto VirtualFreeExit;
}
else
{
ASSERT( "mmap() returned an abnormal value.\n" );
bRetVal = FALSE;
pthrCurrent->SetLastError( ERROR_INTERNAL_ERROR );
goto VirtualFreeExit;
}
}
if ( dwFreeType & MEM_RELEASE )
{
PCMI pMemoryToBeReleased =
VIRTUALFindRegionInformation( (UINT_PTR)lpAddress );
if ( !pMemoryToBeReleased )
{
ERROR( "lpAddress must be the base address returned by VirtualAlloc.\n" );
pthrCurrent->SetLastError( ERROR_INVALID_ADDRESS );
bRetVal = FALSE;
goto VirtualFreeExit;
}
if ( dwSize != 0 )
{
ERROR( "dwSize must be 0 if you are releasing the memory.\n" );
pthrCurrent->SetLastError( ERROR_INVALID_PARAMETER );
bRetVal = FALSE;
goto VirtualFreeExit;
}
TRACE( "Releasing the following memory %d to %d.\n",
pMemoryToBeReleased->startBoundary, pMemoryToBeReleased->memSize );
if ( munmap( (LPVOID)pMemoryToBeReleased->startBoundary,
pMemoryToBeReleased->memSize ) == 0 )
{
if ( VIRTUALReleaseMemory( pMemoryToBeReleased ) == FALSE )
{
ASSERT( "Unable to remove the PCMI entry from the list.\n" );
pthrCurrent->SetLastError( ERROR_INTERNAL_ERROR );
bRetVal = FALSE;
goto VirtualFreeExit;
}
pMemoryToBeReleased = NULL;
}
else
{
ASSERT( "Unable to unmap the memory, munmap() returned an abnormal value.\n" );
pthrCurrent->SetLastError( ERROR_INTERNAL_ERROR );
bRetVal = FALSE;
goto VirtualFreeExit;
}
}
VirtualFreeExit:
LogVaOperation(
(dwFreeType & MEM_DECOMMIT) ? VirtualMemoryLogging::VirtualOperation::Decommit
: VirtualMemoryLogging::VirtualOperation::Release,
lpAddress,
dwSize,
dwFreeType,
0,
NULL,
bRetVal);
InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);
LOGEXIT( "VirtualFree returning %s.\n", bRetVal == TRUE ? "TRUE" : "FALSE" );
PERF_EXIT(VirtualFree);
return bRetVal;
}
/*++
Function:
VirtualProtect
See MSDN doc.
--*/
BOOL
PALAPI
VirtualProtect(
IN LPVOID lpAddress,
IN SIZE_T dwSize,
IN DWORD flNewProtect,
OUT PDWORD lpflOldProtect)
{
BOOL bRetVal = FALSE;
PCMI pEntry = NULL;
SIZE_T MemSize = 0;
UINT_PTR StartBoundary = 0;
SIZE_T Index = 0;
SIZE_T NumberOfPagesToChange = 0;
SIZE_T OffSet = 0;
CPalThread * pthrCurrent;
PERF_ENTRY(VirtualProtect);
ENTRY("VirtualProtect(lpAddress=%p, dwSize=%u, flNewProtect=%#x, "
"flOldProtect=%p)\n",
lpAddress, dwSize, flNewProtect, lpflOldProtect);
pthrCurrent = InternalGetCurrentThread();
InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);
StartBoundary = (UINT_PTR)lpAddress & ~VIRTUAL_PAGE_MASK;
MemSize = (((UINT_PTR)(dwSize) + ((UINT_PTR)(lpAddress) & VIRTUAL_PAGE_MASK)
+ VIRTUAL_PAGE_MASK) & ~VIRTUAL_PAGE_MASK);
if ( VIRTUALContainsInvalidProtectionFlags( flNewProtect ) )
{
ASSERT( "flProtect can be one of PAGE_NOACCESS, PAGE_READONLY, "
"PAGE_READWRITE, PAGE_EXECUTE, PAGE_EXECUTE_READ "
", or PAGE_EXECUTE_READWRITE. \n" );
SetLastError( ERROR_INVALID_PARAMETER );
goto ExitVirtualProtect;
}
if ( !lpflOldProtect)
{
ERROR( "lpflOldProtect was invalid.\n" );
SetLastError( ERROR_NOACCESS );
goto ExitVirtualProtect;
}
pEntry = VIRTUALFindRegionInformation( StartBoundary );
if ( NULL != pEntry )
{
/* See if the pages are committed. */
Index = OffSet = StartBoundary - pEntry->startBoundary == 0 ?
0 : ( StartBoundary - pEntry->startBoundary ) / VIRTUAL_PAGE_SIZE;
NumberOfPagesToChange = MemSize / VIRTUAL_PAGE_SIZE;
TRACE( "Number of pages to check %d, starting page %d \n", NumberOfPagesToChange, Index );
for ( ; Index < NumberOfPagesToChange; Index++ )
{
if ( !VIRTUALIsPageCommitted( Index, pEntry ) )
{
ERROR( "You can only change the protection attributes"
" on committed memory.\n" )
SetLastError( ERROR_INVALID_ADDRESS );
goto ExitVirtualProtect;
}
}
}
if ( 0 == mprotect( (LPVOID)StartBoundary, MemSize,
W32toUnixAccessControl( flNewProtect ) ) )
{
/* Reset the access protection. */
TRACE( "Number of pages to change %d, starting page %d \n",
NumberOfPagesToChange, OffSet );
/*
* Set the old protection flags. We only use the first flag, so
* if there were several regions with each with different flags only the
* first region's protection flag will be returned.
*/
if ( pEntry )
{
*lpflOldProtect =
VIRTUALConvertVirtualFlags( pEntry->pProtectionState[ OffSet ] );
memset( pEntry->pProtectionState + OffSet,
VIRTUALConvertWinFlags( flNewProtect ),
NumberOfPagesToChange );
}
else
{
*lpflOldProtect = PAGE_EXECUTE_READWRITE;
}
bRetVal = TRUE;
}
else
{
ERROR( "%s\n", strerror( errno ) );
if ( errno == EINVAL )
{
SetLastError( ERROR_INVALID_ADDRESS );
}
else if ( errno == EACCES )
{
SetLastError( ERROR_INVALID_ACCESS );
}
}
ExitVirtualProtect:
InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);
#if defined _DEBUG
VIRTUALDisplayList();
#endif
LOGEXIT( "VirtualProtect returning %s.\n", bRetVal == TRUE ? "TRUE" : "FALSE" );
PERF_EXIT(VirtualProtect);
return bRetVal;
}
#if HAVE_VM_ALLOCATE
//---------------------------------------------------------------------------------------
//
// Convert a vm_prot_t flag on the Mach kernel to the corresponding memory protection on Windows.
//
// Arguments:
// protection - Mach protection to be converted
//
// Return Value:
// Return the corresponding memory protection on Windows (e.g. PAGE_READ_WRITE, etc.)
//
static DWORD VirtualMapMachProtectToWinProtect(vm_prot_t protection)
{
if (protection & VM_PROT_READ)
{
if (protection & VM_PROT_WRITE)
{
if (protection & VM_PROT_EXECUTE)
{
return PAGE_EXECUTE_READWRITE;
}
else
{
return PAGE_READWRITE;
}
}
else
{
if (protection & VM_PROT_EXECUTE)
{
return PAGE_EXECUTE_READ;
}
else
{
return PAGE_READONLY;
}
}
}
else
{
if (protection & VM_PROT_WRITE)
{
if (protection & VM_PROT_EXECUTE)
{
return PAGE_EXECUTE_WRITECOPY;
}
else
{
return PAGE_WRITECOPY;
}
}
else
{
if (protection & VM_PROT_EXECUTE)
{
return PAGE_EXECUTE;
}
else
{
return PAGE_NOACCESS;
}
}
}
}
static void VM_ALLOCATE_VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer)
{
kern_return_t MachRet;
vm_address_t vm_address;
vm_size_t vm_size;
vm_region_flavor_t vm_flavor;
mach_msg_type_number_t infoCnt;
mach_port_t object_name;
#ifdef BIT64
vm_region_basic_info_data_64_t info;
infoCnt = VM_REGION_BASIC_INFO_COUNT_64;
vm_flavor = VM_REGION_BASIC_INFO_64;
#else
vm_region_basic_info_data_t info;
infoCnt = VM_REGION_BASIC_INFO_COUNT;
vm_flavor = VM_REGION_BASIC_INFO;
#endif
vm_address = (vm_address_t)lpAddress;
#ifdef BIT64
MachRet = vm_region_64(
#else
MachRet = vm_region(
#endif
mach_task_self(),
&vm_address,
&vm_size,
vm_flavor,
(vm_region_info_t)&info,
&infoCnt,
&object_name);
if (MachRet != KERN_SUCCESS) {
return;
}
if (vm_address > (vm_address_t)lpAddress) {
/* lpAddress was pointing into a free region */
lpBuffer->State = MEM_FREE;
return;
}
lpBuffer->BaseAddress = (PVOID)vm_address;
// We don't actually have any information on the Mach kernel which maps to AllocationProtect.
lpBuffer->AllocationProtect = VM_PROT_NONE;
lpBuffer->RegionSize = (SIZE_T)vm_size;
if (info.reserved)
{
lpBuffer->State = MEM_RESERVE;
}
else
{
lpBuffer->State = MEM_COMMIT;
}
lpBuffer->Protect = VirtualMapMachProtectToWinProtect(info.protection);
/* Note that if a mapped region and a private region are adjacent, this
will return MEM_PRIVATE but the region size will span
both the mapped and private regions. */
if (!info.shared)
{
lpBuffer->Type = MEM_PRIVATE;
}
else
{
// What should this be? It's either MEM_MAPPED or MEM_IMAGE, but without an image list,
// we can't determine which one it is.
lpBuffer->Type = MEM_MAPPED;
}
}
#endif // HAVE_VM_ALLOCATE
/*++
Function:
VirtualQuery
See MSDN doc.
--*/
SIZE_T
PALAPI
VirtualQuery(
IN LPCVOID lpAddress,
OUT PMEMORY_BASIC_INFORMATION lpBuffer,
IN SIZE_T dwLength)
{
PCMI pEntry = NULL;
UINT_PTR StartBoundary = 0;
CPalThread * pthrCurrent;
PERF_ENTRY(VirtualQuery);
ENTRY("VirtualQuery(lpAddress=%p, lpBuffer=%p, dwLength=%u)\n",
lpAddress, lpBuffer, dwLength);
pthrCurrent = InternalGetCurrentThread();
InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);
if ( !lpBuffer)
{
ERROR( "lpBuffer has to be a valid pointer.\n" );
pthrCurrent->SetLastError( ERROR_NOACCESS );
goto ExitVirtualQuery;
}
if ( dwLength < sizeof( *lpBuffer ) )
{
ERROR( "dwLength cannot be smaller then the size of *lpBuffer.\n" );
pthrCurrent->SetLastError( ERROR_BAD_LENGTH );
goto ExitVirtualQuery;
}
StartBoundary = (UINT_PTR)lpAddress & ~VIRTUAL_PAGE_MASK;
#if MMAP_IGNORES_HINT
// Make sure we have memory to map before we try to query it.
VIRTUALGetBackingFile(pthrCurrent);
// If we're suballocating, claim that any memory that isn't in our
// suballocated block is already allocated. This keeps callers from
// using these results to try to allocate those blocks and failing.
if (StartBoundary < (UINT_PTR) gBackingBaseAddress ||
StartBoundary >= (UINT_PTR) gBackingBaseAddress + BACKING_FILE_SIZE)
{
if (StartBoundary < (UINT_PTR) gBackingBaseAddress)
{
lpBuffer->RegionSize = (UINT_PTR) gBackingBaseAddress - StartBoundary;
}
else
{
lpBuffer->RegionSize = -StartBoundary;
}
lpBuffer->BaseAddress = (void *) StartBoundary;
lpBuffer->State = MEM_COMMIT;
lpBuffer->Type = MEM_MAPPED;
lpBuffer->AllocationProtect = 0;
lpBuffer->Protect = 0;
goto ExitVirtualQuery;
}
#endif // MMAP_IGNORES_HINT
/* Find the entry. */
pEntry = VIRTUALFindRegionInformation( StartBoundary );
if ( !pEntry )
{
/* Can't find a match, or no list present. */
/* Next, looking for this region in file maps */
if (!MAPGetRegionInfo((LPVOID)StartBoundary, lpBuffer))
{
// When all else fails, call vm_region() if it's available.
// Initialize the State to be MEM_FREE, in which case AllocationBase, AllocationProtect,
// Protect, and Type are all undefined.
lpBuffer->BaseAddress = (LPVOID)StartBoundary;
lpBuffer->RegionSize = 0;
lpBuffer->State = MEM_FREE;
#if HAVE_VM_ALLOCATE
VM_ALLOCATE_VirtualQuery(lpAddress, lpBuffer);
#endif
}
}
else
{
/* Starting page. */
SIZE_T Index = ( StartBoundary - pEntry->startBoundary ) / VIRTUAL_PAGE_SIZE;
/* Attributes to check for. */
BYTE AccessProtection = pEntry->pProtectionState[ Index ];
INT AllocationType = VIRTUALGetAllocationType( Index, pEntry );
SIZE_T RegionSize = 0;
TRACE( "Index = %d, Number of Pages = %d. \n",
Index, pEntry->memSize / VIRTUAL_PAGE_SIZE );
while ( Index < pEntry->memSize / VIRTUAL_PAGE_SIZE &&
VIRTUALGetAllocationType( Index, pEntry ) == AllocationType &&
pEntry->pProtectionState[ Index ] == AccessProtection )
{
RegionSize += VIRTUAL_PAGE_SIZE;
Index++;
}
TRACE( "RegionSize = %d.\n", RegionSize );
/* Fill the structure.*/
lpBuffer->AllocationProtect = pEntry->accessProtection;
lpBuffer->BaseAddress = (LPVOID)StartBoundary;
lpBuffer->Protect = AllocationType == MEM_COMMIT ?
VIRTUALConvertVirtualFlags( AccessProtection ) : 0;
lpBuffer->RegionSize = RegionSize;
lpBuffer->State =
( AllocationType == MEM_COMMIT ? MEM_COMMIT : MEM_RESERVE );
WARN( "Ignoring lpBuffer->Type. \n" );
}
ExitVirtualQuery:
InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);
LOGEXIT( "VirtualQuery returning %d.\n", sizeof( *lpBuffer ) );
PERF_EXIT(VirtualQuery);
return sizeof( *lpBuffer );
}
/*++
Function:
GetWriteWatch
See MSDN doc.
--*/
UINT
PALAPI
GetWriteWatch(
IN DWORD dwFlags,
IN PVOID lpBaseAddress,
IN SIZE_T dwRegionSize,
OUT PVOID *lpAddresses,
IN OUT PULONG_PTR lpdwCount,
OUT PULONG lpdwGranularity
)
{
// TODO: implement this method
*lpAddresses = NULL;
*lpdwCount = 0;
// Until it is implemented, return non-zero value as an indicator of failure
return 1;
}
/*++
Function:
ResetWriteWatch
See MSDN doc.
--*/
UINT
PALAPI
ResetWriteWatch(
IN LPVOID lpBaseAddress,
IN SIZE_T dwRegionSize
)
{
// TODO: implement this method
// Until it is implemented, return non-zero value as an indicator of failure
return 1;
}
/*++
Function :
ReserveMemoryFromExecutableAllocator
This function is used to reserve a region of virual memory (not commited)
that is located close to the coreclr library. The memory comes from the virtual
address range that is managed by ExecutableMemoryAllocator.
--*/
void* ReserveMemoryFromExecutableAllocator(CPalThread* pThread, SIZE_T allocationSize)
{
InternalEnterCriticalSection(pThread, &virtual_critsec);
void* mem = g_executableMemoryAllocator.AllocateMemory(allocationSize);
InternalLeaveCriticalSection(pThread, &virtual_critsec);
return mem;
}
/*++
Function:
ExecutableMemoryAllocator::Initialize()
This function initializes the allocator. It should be called early during process startup
(when process address space is pretty much empty) in order to have a chance to reserve
sufficient amount of memory that is close to the coreclr library.
--*/
void ExecutableMemoryAllocator::Initialize()
{
m_startAddress = NULL;
m_nextFreeAddress = NULL;
m_totalSizeOfReservedMemory = 0;
m_remainingReservedMemory = 0;
// Enable the executable memory allocator on 64-bit platforms only
// because 32-bit platforms have limited amount of virtual address space.
#ifdef BIT64
TryReserveInitialMemory();
#endif // BIT64
}
/*++
Function:
ExecutableMemoryAllocator::TryReserveInitialMemory()
This function is called during PAL initialization. It opportunistically tries to reserve
a large chunk of virtual memory that can be later used to store JIT'ed code.\
--*/
void ExecutableMemoryAllocator::TryReserveInitialMemory()
{
CPalThread* pthrCurrent = InternalGetCurrentThread();
int32_t sizeOfAllocation = MaxExecutableMemorySize;
int32_t startAddressIncrement;
UINT_PTR startAddress;
UINT_PTR coreclrLoadAddress;
const int32_t MemoryProbingIncrement = 128 * 1024 * 1024;
// Try to find and reserve an available region of virtual memory that is located
// within 2GB range (defined by the MaxExecutableMemorySize constant) from the
// location of the coreclr library.
// Potentially, as a possible future improvement, we can get precise information
// about available memory ranges by parsing data from '/proc/self/maps'.
// But since this code is called early during process startup, the user address space
// is pretty much empty so the simple algorithm that is implemented below is sufficient
// for this purpose.
// First of all, we need to determine the current address of libcoreclr. Please note that depending on
// the OS implementation, the library is usually loaded either at the end or at the start of the user
// address space. If the library is loaded at low addresses then try to reserve memory above libcoreclr
// (thus avoiding reserving memory below 4GB; besides some operating systems do not allow that).
// If libcoreclr is loaded at high addresses then try to reserve memory below its location.
coreclrLoadAddress = (UINT_PTR)PAL_GetSymbolModuleBase((void*)VirtualAlloc);
if ((coreclrLoadAddress < 0xFFFFFFFF) || ((coreclrLoadAddress - MaxExecutableMemorySize) < 0xFFFFFFFF))
{
// Try to allocate above the location of libcoreclr
startAddress = coreclrLoadAddress + CoreClrLibrarySize;
startAddressIncrement = MemoryProbingIncrement;
}
else
{
// Try to allocate below the location of libcoreclr
startAddress = coreclrLoadAddress - MaxExecutableMemorySize;
startAddressIncrement = 0;
}
// Do actual memory reservation.
do
{
m_startAddress = ReserveVirtualMemory(pthrCurrent, (void*)startAddress, sizeOfAllocation);
if (m_startAddress != NULL)
{
// Memory has been successfully reserved.
m_totalSizeOfReservedMemory = sizeOfAllocation;
// Randomize the location at which we start allocating from the reserved memory range.
int32_t randomOffset = GenerateRandomStartOffset();
m_nextFreeAddress = (void*)(((UINT_PTR)m_startAddress) + randomOffset);
m_remainingReservedMemory = sizeOfAllocation - randomOffset;
break;
}
// Try to allocate a smaller region
sizeOfAllocation -= MemoryProbingIncrement;
startAddress += startAddressIncrement;
} while (sizeOfAllocation >= MemoryProbingIncrement);
}
/*++
Function:
ExecutableMemoryAllocator::AllocateMemory
This function attempts to allocate the requested amount of memory from its reserved virtual
address space. The function will return NULL if the allocation request cannot
be satisfied by the memory that is currently available in the allocator.
Note: This function MUST be called with the virtual_critsec lock held.
--*/
void* ExecutableMemoryAllocator::AllocateMemory(SIZE_T allocationSize)
{
void* allocatedMemory = NULL;
// Allocation size must be in multiples of the virtual page size.
_ASSERTE((allocationSize & VIRTUAL_PAGE_MASK) == 0);
// The code below assumes that the caller owns the virtual_critsec lock.
// So the calculations are not done in thread-safe manner.
if ((allocationSize > 0) && (allocationSize <= m_remainingReservedMemory))
{
allocatedMemory = m_nextFreeAddress;
m_nextFreeAddress = (void*)(((UINT_PTR)m_nextFreeAddress) + allocationSize);
m_remainingReservedMemory -= allocationSize;
}
return allocatedMemory;
}
/*++
Function:
ExecutableMemoryAllocator::GenerateRandomStartOffset()
This function returns a random offset (in multiples of the virtual page size)
at which the allocator should start allocating memory from its reserved memory range.
--*/
int32_t ExecutableMemoryAllocator::GenerateRandomStartOffset()
{
int32_t pageCount;
const int32_t MaxStartPageOffset = 64;
// This code is similar to what coreclr runtime does on Windows.
// It generates a random number of pages to skip between 0...MaxStartPageOffset.
srandom(time(NULL));
pageCount = (int32_t)(MaxStartPageOffset * (int64_t)random() / RAND_MAX);
return pageCount * VIRTUAL_PAGE_SIZE;
}
| 30.198063 | 108 | 0.614474 | chrisaut |
4b5334791fd558dd47efd07d0e0f53ecfd1088e1 | 1,282 | cc | C++ | handy/port_posix.cc | onlyet/handy | 780548fc7433c7f3ec541b15a7e87efb996a7218 | [
"BSD-2-Clause"
] | 2 | 2018-04-27T15:32:37.000Z | 2019-12-27T13:04:58.000Z | handy/port_posix.cc | OnlYet/handy | 780548fc7433c7f3ec541b15a7e87efb996a7218 | [
"BSD-2-Clause"
] | 1 | 2018-11-13T06:41:51.000Z | 2018-11-13T06:41:51.000Z | handy/port_posix.cc | OnlYet/handy | 780548fc7433c7f3ec541b15a7e87efb996a7218 | [
"BSD-2-Clause"
] | null | null | null | #include "port_posix.h"
#include <netdb.h>
#include <pthread.h>
#include <string.h>
#include <sys/syscall.h>
#include <unistd.h>
#define OS_LINUX
namespace handy {
namespace port {
#ifdef OS_LINUX
struct in_addr getHostByName(const std::string &host) {
struct in_addr addr;
char buf[1024];
struct hostent hent;
struct hostent *he = NULL;
int herrno = 0;
memset(&hent, 0, sizeof hent);
int r = gethostbyname_r(host.c_str(), &hent, buf, sizeof buf, &he, &herrno);
if (r == 0 && he && he->h_addrtype == AF_INET) {
addr = *reinterpret_cast<struct in_addr *>(he->h_addr);
} else {
addr.s_addr = INADDR_NONE;
}
return addr;
}
uint64_t gettid() {
return syscall(SYS_gettid);
}
#elif defined(OS_MACOSX)
struct in_addr getHostByName(const std::string &host) {
struct in_addr addr;
struct hostent *he = gethostbyname(host.c_str());
if (he && he->h_addrtype == AF_INET) {
addr = *reinterpret_cast<struct in_addr *>(he->h_addr);
} else {
addr.s_addr = INADDR_NONE;
}
return addr;
}
uint64_t gettid() {
pthread_t tid = pthread_self();
uint64_t uid = 0;
memcpy(&uid, &tid, std::min(sizeof(tid), sizeof(uid)));
return uid;
}
#endif
} // namespace port
} // namespace handy | 25.137255 | 80 | 0.638846 | onlyet |
Subsets and Splits