blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 905
values | visit_date timestamp[us]date 2015-08-09 11:21:18 2023-09-06 10:45:07 | revision_date timestamp[us]date 1997-09-14 05:04:47 2023-09-17 19:19:19 | committer_date timestamp[us]date 1997-09-14 05:04:47 2023-09-06 06:22:19 | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22
values | gha_event_created_at timestamp[us]date 2012-06-07 00:51:45 2023-09-14 21:58:39 ⌀ | gha_created_at timestamp[us]date 2008-03-27 23:40:48 2023-08-21 23:17:38 ⌀ | gha_language stringclasses 141
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 10.4M | extension stringclasses 115
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
cf5e4c33922b95b2795aa8357101f848a1f06665 | 4cd7f9447801592739d8b05c4f41f9f210fdb784 | /src/extensions/utility/unpacker_unittest.cc | bb99aaeed246a6d4a279e24bf213019abdb67626 | [
"BSD-3-Clause"
] | permissive | crash0verrid3/Firework-Browser | 15fbcdcdf521f1b1a1f609310fba9a5ab520b92a | 9f2e99135fa4230581bde1806ca51e484372be50 | refs/heads/master | 2021-01-10T13:18:41.267236 | 2015-10-18T23:04:10 | 2015-10-18T23:04:10 | 44,147,842 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,364 | cc | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/path_service.h"
#include "base/strings/pattern.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "extensions/common/constants.h"
#include "extensions/common/extension.h"
#include "extensions/common/extension_paths.h"
#include "extensions/common/manifest_constants.h"
#include "extensions/test/test_extensions_client.h"
#include "extensions/utility/unpacker.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/zlib/google/zip.h"
using base::ASCIIToUTF16;
namespace extensions {
namespace errors = manifest_errors;
namespace keys = manifest_keys;
class UnpackerTest : public testing::Test {
public:
~UnpackerTest() override {
VLOG(1) << "Deleting temp dir: " << temp_dir_.path().LossyDisplayName();
VLOG(1) << temp_dir_.Delete();
}
void SetupUnpacker(const std::string& crx_name) {
base::FilePath crx_path;
ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &crx_path));
crx_path = crx_path.AppendASCII("unpacker").AppendASCII(crx_name);
ASSERT_TRUE(base::PathExists(crx_path)) << crx_path.value();
// Try bots won't let us write into DIR_TEST_DATA, so we have to create
// a temp folder to play in.
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
base::FilePath unzipped_dir = temp_dir_.path().AppendASCII("unzipped");
ASSERT_TRUE(zip::Unzip(crx_path, unzipped_dir))
<< "Failed to unzip " << crx_path.value() << " to "
<< unzipped_dir.value();
unpacker_.reset(new Unpacker(temp_dir_.path(), unzipped_dir, std::string(),
Manifest::INTERNAL, Extension::NO_FLAGS));
}
protected:
base::ScopedTempDir temp_dir_;
scoped_ptr<Unpacker> unpacker_;
};
TEST_F(UnpackerTest, EmptyDefaultLocale) {
SetupUnpacker("empty_default_locale.crx");
EXPECT_FALSE(unpacker_->Run());
EXPECT_EQ(ASCIIToUTF16(errors::kInvalidDefaultLocale),
unpacker_->error_message());
}
TEST_F(UnpackerTest, HasDefaultLocaleMissingLocalesFolder) {
SetupUnpacker("has_default_missing_locales.crx");
EXPECT_FALSE(unpacker_->Run());
EXPECT_EQ(ASCIIToUTF16(errors::kLocalesTreeMissing),
unpacker_->error_message());
}
TEST_F(UnpackerTest, InvalidDefaultLocale) {
SetupUnpacker("invalid_default_locale.crx");
EXPECT_FALSE(unpacker_->Run());
EXPECT_EQ(ASCIIToUTF16(errors::kInvalidDefaultLocale),
unpacker_->error_message());
}
TEST_F(UnpackerTest, InvalidMessagesFile) {
SetupUnpacker("invalid_messages_file.crx");
EXPECT_FALSE(unpacker_->Run());
EXPECT_TRUE(base::MatchPattern(
unpacker_->error_message(),
ASCIIToUTF16(
"*_locales?en_US?messages.json: Line: 2, column: 11,"
" Syntax error.")))
<< unpacker_->error_message();
}
TEST_F(UnpackerTest, MissingDefaultData) {
SetupUnpacker("missing_default_data.crx");
EXPECT_FALSE(unpacker_->Run());
EXPECT_EQ(ASCIIToUTF16(errors::kLocalesNoDefaultMessages),
unpacker_->error_message());
}
TEST_F(UnpackerTest, MissingDefaultLocaleHasLocalesFolder) {
SetupUnpacker("missing_default_has_locales.crx");
EXPECT_FALSE(unpacker_->Run());
EXPECT_EQ(ASCIIToUTF16(errors::kLocalesNoDefaultLocaleSpecified),
unpacker_->error_message());
}
TEST_F(UnpackerTest, MissingMessagesFile) {
SetupUnpacker("missing_messages_file.crx");
EXPECT_FALSE(unpacker_->Run());
EXPECT_TRUE(
base::MatchPattern(unpacker_->error_message(),
ASCIIToUTF16(errors::kLocalesMessagesFileMissing) +
ASCIIToUTF16("*_locales?en_US?messages.json")));
}
TEST_F(UnpackerTest, NoLocaleData) {
SetupUnpacker("no_locale_data.crx");
EXPECT_FALSE(unpacker_->Run());
EXPECT_EQ(ASCIIToUTF16(errors::kLocalesNoDefaultMessages),
unpacker_->error_message());
}
TEST_F(UnpackerTest, GoodL10n) {
SetupUnpacker("good_l10n.crx");
EXPECT_TRUE(unpacker_->Run());
EXPECT_TRUE(unpacker_->error_message().empty());
ASSERT_EQ(2U, unpacker_->parsed_catalogs()->size());
}
TEST_F(UnpackerTest, NoL10n) {
SetupUnpacker("no_l10n.crx");
EXPECT_TRUE(unpacker_->Run());
EXPECT_TRUE(unpacker_->error_message().empty());
EXPECT_EQ(0U, unpacker_->parsed_catalogs()->size());
}
namespace {
// Inserts an illegal path into the browser images returned by
// TestExtensionsClient for any extension.
class IllegalImagePathInserter
: public TestExtensionsClient::BrowserImagePathsFilter {
public:
IllegalImagePathInserter(TestExtensionsClient* client) : client_(client) {
client_->AddBrowserImagePathsFilter(this);
}
virtual ~IllegalImagePathInserter() {
client_->RemoveBrowserImagePathsFilter(this);
}
void Filter(const Extension* extension,
std::set<base::FilePath>* paths) override {
base::FilePath illegal_path =
base::FilePath(base::FilePath::kParentDirectory)
.AppendASCII(kTempExtensionName)
.AppendASCII("product_logo_128.png");
paths->insert(illegal_path);
}
private:
TestExtensionsClient* client_;
};
} // namespace
TEST_F(UnpackerTest, BadPathError) {
const char kExpected[] = "Illegal path (absolute or relative with '..'): ";
SetupUnpacker("good_package.crx");
IllegalImagePathInserter inserter(
static_cast<TestExtensionsClient*>(ExtensionsClient::Get()));
EXPECT_FALSE(unpacker_->Run());
EXPECT_TRUE(base::StartsWith(unpacker_->error_message(),
ASCIIToUTF16(kExpected), false))
<< "Expected prefix: \"" << kExpected << "\", actual error: \""
<< unpacker_->error_message() << "\"";
}
TEST_F(UnpackerTest, ImageDecodingError) {
const char kExpected[] = "Could not decode image: ";
SetupUnpacker("bad_image.crx");
EXPECT_FALSE(unpacker_->Run());
EXPECT_TRUE(base::StartsWith(unpacker_->error_message(),
ASCIIToUTF16(kExpected), false))
<< "Expected prefix: \"" << kExpected << "\", actual error: \""
<< unpacker_->error_message() << "\"";
}
} // namespace extensions
| [
"sasha@sasha-kaidalov"
] | sasha@sasha-kaidalov |
b32efa24de3a982d3ab6e5b81c066c79081ceaca | 0471b930818308c0759a663591240929d046a542 | /FCC/WorkDir/Detector_Changes_Histograms.cxx | ae600c7868f191f6b08b3fab508839694412e2f4 | [] | no_license | jones117a/FCC | e992bba4dc4cef18a8cd9c10c25666c9fd8430ff | a4892d45c51e0ec83f42bb2a5fed8fe56402be27 | refs/heads/master | 2021-01-02T22:19:27.094123 | 2017-09-06T12:48:39 | 2017-09-06T12:48:39 | 99,316,146 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,224 | cxx | #include "TH1F.h"
#include "TTree.h"
#include "TCanvas.h"
#include "TFile.h"
#include "THStack.h"
void Detector_Changes_Histograms()
{
double L = 5000.; //Integrated luminosity in inverse fb
double Xsec_HZ_BR_Hgamgam = 0.4; //Cross-section * BR in fb
double N_Exp_Signal = L * Xsec_HZ_BR_Hgamgam;
double N_Gen_Signal = 39361.;
double Signal_Hist_Scale_Factor = N_Exp_Signal / N_Gen_Signal;
TFile * Signal_File = new TFile("OutDir_1/ee_ZH_Z_Hgamgam_4/heppy.analyzers.examples.zh_hgamgam.TreeProducer.TreeProducer_1/tree.root", "Read");
TTree * Signal_Tree = (TTree*)Signal_File->Get("events");
TH1F * Signal_Higgs_Mass_Hist = new TH1F("Signal_Higgs_Mass", "Mass of reconstructed Higgs particles", 60, 110, 140);
Signal_Higgs_Mass_Hist->Sumw2();
Signal_Tree->SetBranchStatus("*", 0);
Signal_Tree->SetBranchStatus("higgs_m", 1);
double Signal_Higgs_Mass;
Signal_Tree->SetBranchAddress("higgs_m", &Signal_Higgs_Mass);
for (int Higgs_Number = 0; Higgs_Number < Signal_Tree->GetEntries(); ++ Higgs_Number)
{
Signal_Tree->GetEntry(Higgs_Number);
Signal_Higgs_Mass_Hist->Fill(Signal_Higgs_Mass);
}
Signal_Higgs_Mass_Hist->Scale(Signal_Hist_Scale_Factor);
TCanvas * c1 = new TCanvas("c1", "Higgs reconstruction histograms", 800, 600);
gStyle->SetOptStat(0);
gStyle->SetOptFit();
Signal_Higgs_Mass_Hist->SetLineColor(kBlue);
Signal_Higgs_Mass_Hist->SetLineWidth(3);
Signal_Higgs_Mass_Hist->Draw("hist");
Signal_Higgs_Mass_Hist->Draw("func same");
Signal_Higgs_Mass_Hist->SetAxisRange(0., 300.,"Y");
Signal_Higgs_Mass_Hist->GetXaxis()->SetTitle("Higgs Mass/GeV");
Signal_Higgs_Mass_Hist->GetYaxis()->SetTitle("Number of events/500 MeV");
Signal_Higgs_Mass_Hist->SetTitle("CMS Detector");
Signal_Higgs_Mass_Hist->GetYaxis()->SetTitleOffset(1.4);
Signal_Higgs_Mass_Hist->Fit("gaus");
TLegend * Mass_Legend = new TLegend(0.15,0.8,0.25,0.9);
Mass_Legend->SetHeader("Mass histogram legend");
Mass_Legend->AddEntry(Signal_Higgs_Mass_Hist, "Signal Histogram", "l");
Mass_Legend->Draw();
c1->Update();
c1->Draw();
c1->Print("CMS_Detector.pdf");
return;
}
| [
"eljones@lxplus063.cern.ch"
] | eljones@lxplus063.cern.ch |
e3099c07e2bc5f6bdad2727335ec29411fb6ab04 | d4dbb31f23648b9db03170f68986150d94600117 | /src/ResourceManager.hpp | 6f3beef6b6db49ec01fecdb7738dcb78edfda84d | [] | no_license | hahahahaman/Lights-Demo | 03dd16ed5e41af6907b51c26d40df7064607e3b7 | 62b40baff333baafc2c0214c0341601e7cef3854 | refs/heads/master | 2021-01-25T08:32:15.575524 | 2014-05-14T23:23:22 | 2014-05-14T23:23:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,991 | hpp | /*
ResourceManager.hpp
2013-03-01-01.06.06
*/
#ifndef RESOURCEMANAGER_HPP
#define RESOURCEMANAGER_HPP
#include <string>
#include <unordered_map>
template< class T >
class ResourceManager
{
public:
typedef std::pair< std::string, T* > Resource;
typedef std::unordered_map< std::string, T* > ResourceMap;
protected:
ResourceMap m_resource;
T* find( const std::string& strId )
{
T* resource = NULL;
typename ResourceMap::iterator it = m_resource.find( strId );
if( it != m_resource.end() )
{
resource = it->second;
}
return resource;
}
virtual T* load( const std::string& strId ) = 0;
public:
ResourceManager()
{
}
virtual ~ResourceManager()
{
releaseAllResources();
}
virtual T* getResource( const std::string& strId )
{
T* resource = find( strId );
if( resource == NULL )
{
resource = load( strId );
// If the resource loaded successfully, add it to the resource map
if( resource != NULL )
m_resource.insert( Resource( strId, resource ) );
}
return resource;
}
void releaseResource( const std::string& strId)
{
T* resource = find( strId );
if( resource != NULL )
{
delete resource;
m_resource.erase( m_resource.find( strId ) );
}
}
void releaseAllResources()
{
while( m_resource.begin() != m_resource.end() )
{
delete m_resource.begin()->second;
m_resource.erase( m_resource.begin() );
}
}
};
#endif // RESOURCEMANAGER_H_INCLUDED
| [
"hahahadude@gmail.com"
] | hahahadude@gmail.com |
9bfeed1d94a3ebb36e6f6f54ce79d275f4ca3925 | eeaffce1640320bef9dec2629788dd2b70351c20 | /runtime/separate.h | 408f05e41c7ea55b5961386e37b10d04398bbc7d | [] | no_license | elshyam/demo-container-runtime | ea648a26551a8310dd0458ac8685dbbe2c04a66a | f24e4559c1b5b6a45d8b7320275de54e152576c1 | refs/heads/master | 2022-07-28T05:14:15.064803 | 2020-05-13T07:59:52 | 2020-05-13T07:59:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 345 | h | #ifndef DEMO_CONTAINER_RUNTIME_SEPARATE_H
#define DEMO_CONTAINER_RUNTIME_SEPARATE_H
#include <vector>
#include <string>
#include "plugin/SeparationPlugin.h"
#include "plugin/SeparationPluginList.h"
int run_separated(const SeparationPluginList &pluginList, const std::vector<std::string> &argvList);
#endif //DEMO_CONTAINER_RUNTIME_SEPARATE_H
| [
"janos@pasztor.at"
] | janos@pasztor.at |
005245f7817834c6e2ba8b915c506b370b641528 | b4052809a4a08eb9ddc4551b6fc34ef61b90a24c | /frameworks/vtk.framework/Headers/vtkGraphToPoints.h | 4b283f4dd1ea58c2354aa83721b241df87d413ea | [] | no_license | 9gel/hellopcl | 548687167b0b17bd393b55f37e99d05207971a9e | 19c39b39ad169c0a79b42cd72232d51b419f4f3d | refs/heads/master | 2020-02-26T17:05:09.470167 | 2014-02-27T07:59:52 | 2014-02-27T07:59:52 | 17,192,517 | 21 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 2,101 | h | /*=========================================================================
Program: Visualization Toolkit
Module: vtkGraphToPoints.h
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.
=========================================================================*/
/*-------------------------------------------------------------------------
Copyright 2008 Sandia Corporation.
Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
the U.S. Government retains certain rights in this software.
-------------------------------------------------------------------------*/
// .NAME vtkGraphToPoints - convert a vtkGraph a set of points.
//
// .SECTION Description
// Converts a vtkGraph to a vtkPolyData containing a set of points.
// This assumes that the points
// of the graph have already been filled (perhaps by vtkGraphLayout).
// The vertex data is passed along to the point data.
#ifndef __vtkGraphToPoints_h
#define __vtkGraphToPoints_h
#include "vtkFiltersGeneralModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
class VTKFILTERSGENERAL_EXPORT vtkGraphToPoints : public vtkPolyDataAlgorithm
{
public:
static vtkGraphToPoints *New();
vtkTypeMacro(vtkGraphToPoints,vtkPolyDataAlgorithm);
void PrintSelf(ostream& os, vtkIndent indent);
protected:
vtkGraphToPoints();
~vtkGraphToPoints() {}
// Description:
// Convert the vtkGraph into vtkPolyData.
int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
// Description:
// Set the input type of the algorithm to vtkGraph.
int FillInputPortInformation(int port, vtkInformation* info);
private:
vtkGraphToPoints(const vtkGraphToPoints&); // Not implemented.
void operator=(const vtkGraphToPoints&); // Not implemented.
};
#endif
| [
"nigel@vannevartech.com"
] | nigel@vannevartech.com |
d0018b0ed98d4ddcede351ebbfef4e0125d29171 | 12ac0673d43abcc55c9b7d7a81d0f47848386a6f | /src/Commands/moveServos.h | bdf9e663f31c6d421f1243f6ab6f7340b6175305 | [] | no_license | plahera/RobotTestNew | c7e425584626a18aaf8240c429fef2fef06109d9 | d2ed375aca7ed8f57c08f9fce88137e9e17bfebb | refs/heads/master | 2021-01-10T06:21:28.745492 | 2016-03-04T01:48:27 | 2016-03-04T01:48:27 | 52,684,882 | 0 | 1 | null | 2016-03-04T01:48:28 | 2016-02-27T19:32:55 | C++ | UTF-8 | C++ | false | false | 1,094 | h | // RobotBuilder Version: 2.0
//
// This file was generated by RobotBuilder. It contains sections of
// code that are automatically generated and assigned by robotbuilder.
// These sections will be updated in the future when you export to
// C++ from RobotBuilder. Do not put any code or make any change in
// the blocks indicating autogenerated code or it will be lost on an
// update. Deleting the comments indicating the section will prevent
// it from being updated in the future.
#ifndef MOVESERVOS_H
#define MOVESERVOS_H
#include "Commands/Subsystem.h"
#include "../Robot.h"
/**
*
*
* @author ExampleAuthor
*/
class moveServos: public Command {
public:
// BEGIN AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=CONSTRUCTOR
moveServos();
// END AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=CONSTRUCTOR
virtual void Initialize();
virtual void Execute();
virtual bool IsFinished();
virtual void End();
virtual void Interrupted();
private:
// BEGIN AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=VARIABLES
// END AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=VARIABLES
};
#endif
| [
"plahera1@hwemail.com"
] | plahera1@hwemail.com |
729936c64255a05c20e3e2b2865bdcba0c873ecd | 7a623a8ad3d41b6180b89225f43b134c8cfc57b7 | /ash/components/shortcut_viewer/views/keyboard_shortcut_view.cc | dc9300888f852a3e307af246ac084bc0c61b704c | [
"BSD-3-Clause"
] | permissive | 3031687356/chromium | 9ea7ec7fdec873a7ae242ddb16e2e56c82a21607 | ed4591ba8f0f3c3e85280355b609099f0fb73c3e | refs/heads/master | 2023-02-27T14:07:22.046556 | 2018-08-18T12:51:09 | 2018-08-18T12:51:09 | 145,221,453 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 21,659 | cc | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/components/shortcut_viewer/views/keyboard_shortcut_view.h"
#include <algorithm>
#include "ash/components/shortcut_viewer/keyboard_shortcut_viewer_metadata.h"
#include "ash/components/shortcut_viewer/vector_icons/vector_icons.h"
#include "ash/components/shortcut_viewer/views/keyboard_shortcut_item_list_view.h"
#include "ash/components/shortcut_viewer/views/keyboard_shortcut_item_view.h"
#include "ash/components/shortcut_viewer/views/ksv_search_box_view.h"
#include "ash/components/strings/grit/ash_components_strings.h"
#include "ash/public/cpp/app_list/internal_app_id_constants.h"
#include "ash/public/cpp/resources/grit/ash_public_unscaled_resources.h"
#include "ash/public/cpp/shelf_item.h"
#include "ash/public/cpp/window_properties.h"
#include "base/bind.h"
#include "base/i18n/string_search.h"
#include "base/metrics/histogram_macros.h"
#include "base/metrics/user_metrics.h"
#include "base/metrics/user_metrics_action.h"
#include "base/strings/string_number_conversions.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "ui/aura/client/aura_constants.h"
#include "ui/aura/window.h"
#include "ui/base/accelerators/accelerator.h"
#include "ui/base/default_style.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/chromeos/search_box/search_box_view_base.h"
#include "ui/events/event_constants.h"
#include "ui/gfx/paint_vector_icon.h"
#include "ui/gfx/presentation_feedback.h"
#include "ui/views/background.h"
#include "ui/views/border.h"
#include "ui/views/controls/image_view.h"
#include "ui/views/controls/label.h"
#include "ui/views/controls/scroll_view.h"
#include "ui/views/controls/styled_label.h"
#include "ui/views/controls/tabbed_pane/tabbed_pane.h"
#include "ui/views/controls/textfield/textfield.h"
#include "ui/views/layout/box_layout.h"
#include "ui/views/layout/fill_layout.h"
#include "ui/views/widget/widget.h"
namespace keyboard_shortcut_viewer {
namespace {
KeyboardShortcutView* g_ksv_view = nullptr;
constexpr base::nullopt_t kAllCategories = base::nullopt;
// Setups the illustration views for search states, including an icon and a
// descriptive text.
void SetupSearchIllustrationView(views::View* illustration_view,
const gfx::VectorIcon& icon,
int message_id) {
constexpr int kSearchIllustrationIconSize = 150;
constexpr SkColor kSearchIllustrationIconColor =
SkColorSetARGB(0xFF, 0xDA, 0xDC, 0xE0);
illustration_view->set_owned_by_client();
constexpr int kTopPadding = 98;
views::BoxLayout* layout =
illustration_view->SetLayoutManager(std::make_unique<views::BoxLayout>(
views::BoxLayout::kVertical, gfx::Insets(kTopPadding, 0, 0, 0)));
layout->set_main_axis_alignment(views::BoxLayout::MAIN_AXIS_ALIGNMENT_START);
views::ImageView* image_view = new views::ImageView();
image_view->SetImage(
gfx::CreateVectorIcon(icon, kSearchIllustrationIconColor));
image_view->SetImageSize(
gfx::Size(kSearchIllustrationIconSize, kSearchIllustrationIconSize));
illustration_view->AddChildView(image_view);
constexpr SkColor kSearchIllustrationTextColor =
SkColorSetARGB(0xFF, 0x20, 0x21, 0x24);
views::Label* text = new views::Label(l10n_util::GetStringUTF16(message_id));
text->SetEnabledColor(kSearchIllustrationTextColor);
constexpr int kLabelFontSizeDelta = 1;
ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
text->SetFontList(rb.GetFontListWithDelta(
kLabelFontSizeDelta, gfx::Font::NORMAL, gfx::Font::Weight::NORMAL));
illustration_view->AddChildView(text);
}
views::ScrollView* CreateScrollView() {
views::ScrollView* const scroller = new views::ScrollView();
scroller->set_draw_overflow_indicator(false);
scroller->ClipHeightTo(0, 0);
return scroller;
}
} // namespace
KeyboardShortcutView::~KeyboardShortcutView() {
DCHECK_EQ(g_ksv_view, this);
g_ksv_view = nullptr;
}
// static
views::Widget* KeyboardShortcutView::Toggle(base::TimeTicks start_time,
aura::Window* context) {
if (g_ksv_view) {
if (g_ksv_view->GetWidget()->IsActive())
g_ksv_view->GetWidget()->Close();
else
g_ksv_view->GetWidget()->Activate();
} else {
TRACE_EVENT0("shortcut_viewer", "CreateWidget");
base::RecordAction(
base::UserMetricsAction("KeyboardShortcutViewer.CreateWindow"));
views::Widget::InitParams params;
params.delegate = new KeyboardShortcutView;
params.name = "KeyboardShortcutWidget";
// Intentionally don't set bounds. The window will be sized and centered
// based on CalculatePreferredSize().
views::Widget* widget = new views::Widget;
params.context = context;
widget->Init(params);
// Set frame view Active and Inactive colors, both are SK_ColorWHITE.
aura::Window* window = g_ksv_view->GetWidget()->GetNativeWindow();
window->SetProperty(ash::kFrameActiveColorKey, SK_ColorWHITE);
window->SetProperty(ash::kFrameInactiveColorKey, SK_ColorWHITE);
// Set shelf icon.
const ash::ShelfID shelf_id(app_list::kInternalAppIdKeyboardShortcutViewer);
window->SetProperty(ash::kShelfIDKey,
new std::string(shelf_id.Serialize()));
window->SetProperty<int>(ash::kShelfItemTypeKey, ash::TYPE_APP);
// We don't want the KSV window to have a title (per design), however the
// shelf uses the window title to set the shelf item's tooltip text. The
// shelf observes changes to the |kWindowIconKey| property and handles that
// by initializing the shelf item including its tooltip text.
// TODO(wutao): we can remove resource id IDS_KSV_TITLE after implementing
// internal app shelf launcher.
window->SetTitle(l10n_util::GetStringUTF16(IDS_KSV_TITLE));
gfx::ImageSkia* icon =
ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
IDR_SHORTCUT_VIEWER_LOGO_192);
// The new gfx::ImageSkia instance is owned by the window itself.
window->SetProperty(aura::client::kWindowIconKey,
new gfx::ImageSkia(*icon));
g_ksv_view->AddAccelerator(
ui::Accelerator(ui::VKEY_W, ui::EF_CONTROL_DOWN));
g_ksv_view->needs_init_all_categories_ = false;
g_ksv_view->did_first_paint_ = false;
g_ksv_view->GetWidget()->Show();
g_ksv_view->search_box_view_->search_box()->RequestFocus();
widget->GetCompositor()->RequestPresentationTimeForNextFrame(base::BindOnce(
[](base::TimeTicks start_time,
const gfx::PresentationFeedback& feedback) {
UMA_HISTOGRAM_TIMES("Keyboard.ShortcutViewer.StartupTime",
feedback.timestamp - start_time);
},
start_time));
}
return g_ksv_view->GetWidget();
}
const char* KeyboardShortcutView::GetClassName() const {
return "KeyboardShortcutView";
}
bool KeyboardShortcutView::AcceleratorPressed(
const ui::Accelerator& accelerator) {
DCHECK_EQ(ui::VKEY_W, accelerator.key_code());
DCHECK_EQ(ui::EF_CONTROL_DOWN, accelerator.modifiers());
GetWidget()->Close();
return true;
}
void KeyboardShortcutView::Layout() {
gfx::Rect content_bounds(GetContentsBounds());
if (content_bounds.IsEmpty())
return;
constexpr int kSearchBoxTopPadding = 8;
constexpr int kSearchBoxBottomPadding = 16;
constexpr int kSearchBoxHorizontalPadding = 30;
const int left = content_bounds.x();
const int top = content_bounds.y();
gfx::Rect search_box_bounds(search_box_view_->GetPreferredSize());
search_box_bounds.set_width(
std::min(search_box_bounds.width(),
content_bounds.width() - 2 * kSearchBoxHorizontalPadding));
search_box_bounds.set_x(
left + (content_bounds.width() - search_box_bounds.width()) / 2);
search_box_bounds.set_y(top + kSearchBoxTopPadding);
search_box_view_->SetBoundsRect(search_box_bounds);
views::View* content_view = categories_tabbed_pane_->visible()
? categories_tabbed_pane_
: search_results_container_;
const int search_box_used_height = search_box_bounds.height() +
kSearchBoxTopPadding +
kSearchBoxBottomPadding;
content_view->SetBounds(left, top + search_box_used_height,
content_bounds.width(),
content_bounds.height() - search_box_used_height);
}
gfx::Size KeyboardShortcutView::CalculatePreferredSize() const {
return gfx::Size(800, 512);
}
void KeyboardShortcutView::OnPaint(gfx::Canvas* canvas) {
views::View::OnPaint(canvas);
// Skip if it is the first OnPaint event.
if (!did_first_paint_) {
did_first_paint_ = true;
needs_init_all_categories_ = true;
return;
}
if (!needs_init_all_categories_)
return;
needs_init_all_categories_ = false;
// Cannot post a task right after initializing the first category, it will
// have a chance to end up in the same group of drawing commands sent to
// compositor. We can wait for the second OnPaint, which means previous
// drawing commands have been sent to compositor for the next frame and new
// coming commands will be sent for the next-next frame.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(&KeyboardShortcutView::InitCategoriesTabbedPane,
weak_factory_.GetWeakPtr(), kAllCategories));
}
void KeyboardShortcutView::QueryChanged(search_box::SearchBoxViewBase* sender) {
const bool query_empty = sender->IsSearchBoxTrimmedQueryEmpty();
if (is_search_box_empty_ != query_empty) {
is_search_box_empty_ = query_empty;
UpdateViewsLayout(/*is_search_box_active=*/true);
}
debounce_timer_.Stop();
// If search box is empty, do not show |search_results_container_|.
if (query_empty)
return;
// TODO(wutao): This timeout value is chosen based on subjective search
// latency tests on Minnie. Objective method or UMA is desired.
constexpr base::TimeDelta kTimeOut(base::TimeDelta::FromMilliseconds(250));
debounce_timer_.Start(
FROM_HERE, kTimeOut,
base::Bind(&KeyboardShortcutView::ShowSearchResults,
base::Unretained(this), sender->search_box()->text()));
}
void KeyboardShortcutView::BackButtonPressed() {
search_box_view_->ClearSearch();
search_box_view_->SetSearchBoxActive(false, ui::ET_UNKNOWN);
}
void KeyboardShortcutView::ActiveChanged(
search_box::SearchBoxViewBase* sender) {
const bool is_search_box_active = sender->is_search_box_active();
is_search_box_empty_ = sender->IsSearchBoxTrimmedQueryEmpty();
sender->ShowBackOrGoogleIcon(is_search_box_active);
if (is_search_box_active) {
base::RecordAction(
base::UserMetricsAction("KeyboardShortcutViewer.Search"));
}
UpdateViewsLayout(is_search_box_active);
}
KeyboardShortcutView::KeyboardShortcutView() : weak_factory_(this) {
DCHECK_EQ(g_ksv_view, nullptr);
g_ksv_view = this;
// Default background is transparent.
SetBackground(views::CreateSolidBackground(SK_ColorWHITE));
InitViews();
}
void KeyboardShortcutView::InitViews() {
TRACE_EVENT0("shortcut_viewer", "InitViews");
// Init search box view.
search_box_view_ = std::make_unique<KSVSearchBoxView>(this);
search_box_view_->Init();
AddChildView(search_box_view_.get());
// Init no search result illustration view.
search_no_result_view_ = std::make_unique<views::View>();
SetupSearchIllustrationView(search_no_result_view_.get(),
kKsvSearchNoResultIcon, IDS_KSV_SEARCH_NO_RESULT);
// Init search results container view.
search_results_container_ = new views::View();
search_results_container_->SetLayoutManager(
std::make_unique<views::FillLayout>());
search_results_container_->SetVisible(false);
AddChildView(search_results_container_);
// Init views of KeyboardShortcutItemView.
// TODO(https://crbug.com/843394): Observe changes in keyboard layout and
// clear the cache.
KeyboardShortcutItemView::ClearKeycodeToString16Cache();
for (const auto& item : GetKeyboardShortcutItemList()) {
for (auto category : item.categories) {
shortcut_views_.emplace_back(
std::make_unique<KeyboardShortcutItemView>(item, category));
shortcut_views_.back()->set_owned_by_client();
}
}
std::sort(shortcut_views_.begin(), shortcut_views_.end(),
[](const auto& lhs, const auto& rhs) {
if (lhs->category() != rhs->category())
return lhs->category() < rhs->category();
return lhs->description_label_view()->text() <
rhs->description_label_view()->text();
});
// Init views of |categories_tabbed_pane_| and KeyboardShortcutItemListViews.
categories_tabbed_pane_ =
new views::TabbedPane(views::TabbedPane::Orientation::kVertical,
views::TabbedPane::TabStripStyle::kHighlight);
AddChildView(categories_tabbed_pane_);
// Initial Layout of KeyboardShortcutItemView is time consuming. To speed up
// the startup time, we only initialize the first category pane, which is
// visible to user, and defer initialization of other categories in the
// background.
InitCategoriesTabbedPane(ShortcutCategory::kPopular);
}
void KeyboardShortcutView::InitCategoriesTabbedPane(
base::Optional<ShortcutCategory> initial_category) {
// If the tab count is 0, |GetSelectedTabIndex()| will return -1, which we do
// not want to cache.
active_tab_index_ =
std::max(0, categories_tabbed_pane_->GetSelectedTabIndex());
// Although we remove all child views, when the KeyboardShortcutItemView is
// added back to the |categories_tabbed_pane_|, because there is no width
// changes, it will not layout the KeyboardShortcutItemView again due to the
// |MaybeCalculateAndDoLayout()| optimization in KeyboardShortcutItemView.
// Cannot remove |tab_strip_| and |contents_|, child views of the
// |categories_tabbed_pane_|, because they are added in the ctor of
// TabbedPane.
categories_tabbed_pane_->child_at(0)->RemoveAllChildViews(true);
categories_tabbed_pane_->child_at(1)->RemoveAllChildViews(true);
const bool first_init = initial_category.has_value();
ShortcutCategory current_category = ShortcutCategory::kUnknown;
KeyboardShortcutItemListView* item_list_view;
for (const auto& item_view : shortcut_views_) {
const ShortcutCategory category = item_view->category();
DCHECK_NE(ShortcutCategory::kUnknown, category);
if (current_category != category) {
current_category = category;
item_list_view = new KeyboardShortcutItemListView();
views::ScrollView* const scroller = CreateScrollView();
scroller->SetContents(item_list_view);
categories_tabbed_pane_->AddTab(GetStringForCategory(current_category),
scroller);
}
// If |first_init| is true, we only initialize the pane with the
// KeyboardShortcutItemView in the specific category in |initial_category|.
// Otherwise, we will initialize all the panes.
if (first_init && category != initial_category.value())
continue;
if (item_list_view->has_children())
item_list_view->AddHorizontalSeparator();
views::StyledLabel* description_label_view =
item_view->description_label_view();
// Clear any styles used to highlight matched search query in search mode.
description_label_view->ClearStyleRanges();
item_list_view->AddChildView(item_view.get());
// Remove the search query highlight.
description_label_view->Layout();
}
Layout();
}
void KeyboardShortcutView::UpdateViewsLayout(bool is_search_box_active) {
// 1. Search box is not active: show |categories_tabbed_pane_| and focus on
// active tab.
// 2. Search box is active and empty: show |categories_tabbed_pane_| but focus
// on search box.
// 3. Search box is not empty, show |search_results_container_|. Focus is on
// search box.
const bool should_show_search_results =
is_search_box_active && !is_search_box_empty_;
if (!should_show_search_results) {
// Remove all child views, including horizontal separator lines, to prepare
// for showing search results next time.
search_results_container_->RemoveAllChildViews(true);
if (!categories_tabbed_pane_->visible()) {
// Repopulate |categories_tabbed_pane_| child views, which were removed
// when they were added to |search_results_container_|.
InitCategoriesTabbedPane(kAllCategories);
// Select the category that was active before entering search mode.
categories_tabbed_pane_->SelectTabAt(active_tab_index_);
}
}
categories_tabbed_pane_->SetVisible(!should_show_search_results);
search_results_container_->SetVisible(should_show_search_results);
Layout();
SchedulePaint();
}
void KeyboardShortcutView::ShowSearchResults(
const base::string16& search_query) {
search_results_container_->RemoveAllChildViews(true);
auto* search_container_content_view = search_no_result_view_.get();
auto found_items_list_view = std::make_unique<KeyboardShortcutItemListView>();
base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents finder(
search_query);
ShortcutCategory current_category = ShortcutCategory::kUnknown;
bool has_category_item = false;
int number_search_results = 0;
for (const auto& item_view : shortcut_views_) {
base::string16 description_text =
item_view->description_label_view()->text();
base::string16 shortcut_text = item_view->shortcut_label_view()->text();
size_t match_index = -1;
size_t match_length = 0;
// Only highlight |description_label_view_| in KeyboardShortcutItemView.
// |shortcut_label_view_| has customized style ranges for bubble views
// so it may have overlappings with the searched ranges. The highlighted
// behaviors are not defined so we don't highlight
// |shortcut_label_view_|.
if (finder.Search(description_text, &match_index, &match_length) ||
finder.Search(shortcut_text, nullptr, nullptr)) {
const ShortcutCategory category = item_view->category();
if (current_category != category) {
current_category = category;
has_category_item = false;
found_items_list_view->AddCategoryLabel(GetStringForCategory(category));
}
if (has_category_item)
found_items_list_view->AddHorizontalSeparator();
else
has_category_item = true;
// Highlight matched query in |description_label_view_|.
if (match_length > 0) {
views::StyledLabel::RangeStyleInfo style;
views::StyledLabel* description_label_view =
item_view->description_label_view();
// Clear previous styles.
description_label_view->ClearStyleRanges();
style.custom_font = description_label_view->GetDefaultFontList().Derive(
0, gfx::Font::FontStyle::NORMAL, gfx::Font::Weight::BOLD);
description_label_view->AddStyleRange(
gfx::Range(match_index, match_index + match_length), style);
// Apply new styles to highlight matched search query.
description_label_view->Layout();
}
found_items_list_view->AddChildView(item_view.get());
++number_search_results;
}
}
std::vector<base::string16> replacement_strings;
if (found_items_list_view->has_children()) {
replacement_strings.emplace_back(
base::NumberToString16(number_search_results));
// To offset the padding between the bottom of the |search_box_view_| and
// the top of the |search_results_container_|.
constexpr int kTopPadding = -16;
constexpr int kHorizontalPadding = 128;
found_items_list_view->SetBorder(views::CreateEmptyBorder(
gfx::Insets(kTopPadding, kHorizontalPadding, 0, kHorizontalPadding)));
views::ScrollView* const scroller = CreateScrollView();
scroller->SetContents(found_items_list_view.release());
search_container_content_view = scroller;
}
replacement_strings.emplace_back(search_query);
search_box_view_->SetAccessibleValue(l10n_util::GetStringFUTF16(
number_search_results == 0
? IDS_KSV_SEARCH_BOX_ACCESSIBILITY_VALUE_WITHOUT_RESULTS
: IDS_KSV_SEARCH_BOX_ACCESSIBILITY_VALUE_WITH_RESULTS,
replacement_strings, nullptr));
search_results_container_->AddChildView(search_container_content_view);
Layout();
SchedulePaint();
}
bool KeyboardShortcutView::CanMaximize() const {
return false;
}
bool KeyboardShortcutView::CanMinimize() const {
return true;
}
bool KeyboardShortcutView::CanResize() const {
return false;
}
bool KeyboardShortcutView::ShouldShowWindowTitle() const {
return false;
}
views::ClientView* KeyboardShortcutView::CreateClientView(
views::Widget* widget) {
return new views::ClientView(widget, this);
}
KeyboardShortcutView* KeyboardShortcutView::GetInstanceForTesting() {
return g_ksv_view;
}
int KeyboardShortcutView::GetTabCountForTesting() const {
return categories_tabbed_pane_->GetTabCount();
}
const std::vector<std::unique_ptr<KeyboardShortcutItemView>>&
KeyboardShortcutView::GetShortcutViewsForTesting() const {
return shortcut_views_;
}
KSVSearchBoxView* KeyboardShortcutView::GetSearchBoxViewForTesting() {
return search_box_view_.get();
}
} // namespace keyboard_shortcut_viewer
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
9160597ea5112e895ac9684ee4e6340b14ff011f | 3c8cf4de6c08e21b2c10094ef20488e93d7a34be | /TktkUtilityLib/TktkMathLib/src/TktkMath/Vector2.cpp | 13bb02ff117cd91dfeb171a76cb98174b4fec7f9 | [] | no_license | tktk2104/TktkLib | 07762028c8a3a7378d7e82be8f1ed8c6a0cdc97c | 2af549bfb8448ace9f9fee6c2225ea7d2e6329b8 | refs/heads/master | 2022-11-30T12:26:33.290941 | 2020-08-11T17:50:14 | 2020-08-11T17:50:14 | 213,307,835 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 8,532 | cpp | #include "TktkMath/Vector2.h"
#include <cmath>
#include <limits>
#include <algorithm>
#include <stdexcept>
#include "TktkMath/MathHelper.h"
#include "TktkMath/Matrix3.h"
const Vector2 Vector2::zero ( 0.0f, 0.0f);
const Vector2 Vector2::one ( 1.0f, 1.0f);
const Vector2 Vector2::up ( 0.0f, 1.0f);
const Vector2 Vector2::down ( 0.0f, -1.0f);
const Vector2 Vector2::left (-1.0f, 0.0f);
const Vector2 Vector2::right( 1.0f, 0.0f);
const Vector2 Vector2::negativeInfinity(-INFINITY, -INFINITY);
const Vector2 Vector2::positiveInfinity( INFINITY, INFINITY);
Vector2::Vector2(float x, float y)
: x(x)
, y(y)
{
}
Vector2::Vector2(float value)
: x(value)
, y(value)
{
}
float Vector2::operator[](int index) const
{
switch (index)
{
case 0: return x; break;
case 1: return y; break;
}
throw std::runtime_error("vector2 operator[] out of range");
}
float & Vector2::operator[](int index)
{
switch (index)
{
case 0: return x; break;
case 1: return y; break;
}
throw std::runtime_error("vector2 operator[] out of range");
}
Vector2 Vector2::normalize(const Vector2 & value)
{
return Vector2(value).normalized();
}
float Vector2::angle(const Vector2 & vector1, const Vector2 & vector2)
{
float denominator = std::sqrt(vector1.lengthSquared() * vector2.lengthSquared());
if (denominator == 0.0f) return 0.0f;
float dotValue = MathHelper::clamp(dot(vector1, vector2) / denominator, -1.0f, 1.0f);
return MathHelper::acos(dotValue);
}
float Vector2::signedAngle(const Vector2 & vector1, const Vector2 & vector2)
{
float unSignedAngle = angle(vector1, vector2);
// TODO : 曖昧な変数名を直す
float value = vector1.x * vector2.y - vector1.y * vector2.x;
return unSignedAngle * MathHelper::sign(value);
}
float Vector2::dot(const Vector2 & vector1, const Vector2 & vector2)
{
return (vector1.x * vector2.x) + (vector1.y * vector2.y);
}
float Vector2::cross(const Vector2 & vector1, const Vector2 & vector2)
{
return (vector1.x * vector2.y) - (vector1.y * vector2.x);
}
float Vector2::distance(const Vector2 & vector1, const Vector2 & vector2)
{
return (vector2 - vector1).length();
}
float Vector2::distanceSquared(const Vector2 & vector1, const Vector2 & vector2)
{
return (vector2 - vector1).lengthSquared();
}
Vector2 Vector2::lerp(const Vector2 & value1, const Vector2 & value2, float amount)
{
return Vector2(MathHelper::lerp(value1.x, value2.x, amount), MathHelper::lerp(value1.y, value2.y, amount));
}
Vector2 Vector2::lerpUnclamped(const Vector2 & value1, const Vector2 & value2, float amount)
{
return Vector2(MathHelper::lerpUnclamped(value1.x, value2.x, amount), MathHelper::lerpUnclamped(value1.y, value2.y, amount));;
}
Vector2 Vector2::moveTowards(const Vector2 & current, const Vector2 & target, float maxDistanceDelta)
{
float toVectorX = target.x - current.x;
float toVectorY = target.y - current.y;
float sqDist = toVectorX * toVectorX * toVectorY * toVectorY;
if (sqDist == 0 || (maxDistanceDelta >= 0 && sqDist <= maxDistanceDelta * maxDistanceDelta))
return target;
float dist = std::sqrt(sqDist);
return Vector2(
current.x + toVectorX / dist * maxDistanceDelta,
current.y + toVectorY / dist * maxDistanceDelta
);
}
Vector2 Vector2::smoothDamp(const Vector2 & current, const Vector2 & target, Vector2 * currentVelocity, float smoothTime, float maxSpeed, float deltaTime)
{
smoothTime = std::fmax(0.0001f, smoothTime);
float omega = 2.0f / smoothTime;
float x = omega * deltaTime;
// TODO : 謎の数字に謎の式
float exp = 1.0f / (1.0f + x + 0.48f * x * x + 0.235f * x * x * x);
float changeX = current.x - target.x;
float changeY = current.y - target.y;
float maxChange = maxSpeed * smoothTime;
float maxChangeSq = maxChange * maxChange;
float sqDist = changeX * changeX + changeY * changeY;
if (sqDist > maxChangeSq)
{
float mag = sqrt(sqDist);
changeX = changeX / mag * maxChange;
changeY = changeY / mag * maxChange;
}
Vector2 afterCalcTarget = target;
afterCalcTarget.x = current.x - changeX;
afterCalcTarget.y = current.y - changeY;
float tempX = (currentVelocity->x + omega * changeX) * deltaTime;
float tempY = (currentVelocity->y + omega * changeY) * deltaTime;
currentVelocity->x = (currentVelocity->x - omega * tempX) * exp;
currentVelocity->y = (currentVelocity->y - omega * tempY) * exp;
float outputX = afterCalcTarget.x + (changeX + tempX) * exp;
float outputY = afterCalcTarget.y + (changeY + tempY) * exp;
float origMinusCurrentX = target.x - current.x;
float origMinusCurrentY = target.y - current.y;
float outMinusOrigX = outputX - target.x;
float outMinusOrigY = outputY - target.y;
if (origMinusCurrentX * outMinusOrigX + origMinusCurrentY * outMinusOrigY > 0.0f)
{
outputX = target.x;
outputY = target.y;
currentVelocity->x = (outputX - target.x) / deltaTime;
currentVelocity->y = (outputY - target.y) / deltaTime;
}
return Vector2(outputX, outputY);
}
Vector2 Vector2::calculateMin(const Vector2 & vector1, const Vector2 & vector2)
{
return Vector2(std::min(vector1.x, vector2.x), std::min(vector1.y, vector2.y));
}
Vector2 Vector2::calculateMax(const Vector2 & vector1, const Vector2 & vector2)
{
return Vector2(std::max(vector1.x, vector2.x), std::min(vector1.y, vector2.y));
}
Vector2 Vector2::clamp(const Vector2 & value1, const Vector2& min, const Vector2 & max)
{
return Vector2(MathHelper::clamp(value1.x, min.x, max.x), MathHelper::clamp(value1.y, min.y, max.y));
}
Vector2 Vector2::clampLength(const Vector2 & vector1, float maxLength)
{
float sqrLength = vector1.lengthSquared();
if (sqrLength > maxLength * maxLength)
{
float length = std::sqrt(sqrLength);
float normalizedX = vector1.x / length;
float normalizedY = vector1.y / length;
return Vector2(normalizedX * maxLength, normalizedY * maxLength);
}
return vector1;
}
Vector2 Vector2::perpendicular(const Vector2 & inDirection)
{
return Vector2(-inDirection.y, inDirection.x);
}
Vector2 Vector2::reflect(const Vector2 & inDirection, const Vector2 & inNormal)
{
float factor = -2.0f * dot(inNormal, inDirection);
return Vector2(factor * inNormal.x + inDirection.x, factor * inNormal.y + inDirection.y);
}
Vector2 Vector2::scale(const Vector2 & vector1, const Vector2 & vector2)
{
return Vector2(vector1.x * vector2.x, vector1.y * vector2.y);
}
Vector2 Vector2::transform(const Vector2 & position, const Matrix3 & matrix)
{
float w = position.x * matrix.m[0][2] + position.y * matrix.m[1][2] + matrix.m[2][2];
return Vector2(
(position.x * matrix.m[0][0] + position.y * matrix.m[1][0] + matrix.m[2][0]) / w,
(position.x * matrix.m[0][1] + position.y * matrix.m[1][1] + matrix.m[2][1]) / w
);
}
float Vector2::length() const
{
return std::sqrt(dot(*this, *this));
}
float Vector2::lengthSquared() const
{
return dot(*this, *this);
}
Vector2 Vector2::normalized() const
{
float len = length();
if (len > MathHelper::kEpsilon)
{
return Vector2(x / len, y / len);
}
return Vector2::zero;
}
bool Vector2::equals(const Vector2 & other)
{
return (MathHelper::equals(x, other.x) && MathHelper::equals(y, other.y));
}
void Vector2::setValue(float x, float y)
{
Vector2::x = x;
Vector2::y = y;
}
std::string Vector2::toString() const
{
return "[x:" + std::to_string(x) + ", y:" + std::to_string(y) + "]";
}
Vector2 operator-(const Vector2 & v)
{
return Vector2(-v.x, -v.y);
}
Vector2 & operator+=(Vector2 & v1, const Vector2 & v2)
{
v1.x += v2.x;
v1.y += v2.y;
return v1;
}
Vector2 & operator-=(Vector2 & v1, const Vector2 & v2)
{
v1.x -= v2.x;
v1.y -= v2.y;
return v1;
}
Vector2 & operator*=(Vector2 & v, float s)
{
v.x *= s;
v.y *= s;
return v;
}
Vector2 & operator*=(Vector2 & v, const Matrix3 & m)
{
v = v * m;
return v;
}
Vector2 & operator/=(Vector2 & v, float s)
{
v.x /= s;
v.y /= s;
return v;
}
Vector2 operator+(Vector2 v1, const Vector2 & v2)
{
return v1 += v2;
}
Vector2 operator-(Vector2 v1, const Vector2 & v2)
{
return v1 -= v2;
}
Vector2 operator*(Vector2 v, float s)
{
return v *= s;
}
Vector2 operator*(float s, Vector2 v)
{
return v *= s;
}
Vector2 operator*(const Vector2 & v, const Matrix3 & m)
{
return Vector2::transform(v, m);
}
Vector2 operator/(Vector2 v, float s)
{
return v /= s;
}
bool operator==(const Vector2 & lhs, const Vector2 & rhs)
{
return ((lhs.x == rhs.x) && (lhs.y == rhs.y));
}
bool operator!=(const Vector2 & lhs, const Vector2 & rhs)
{
return !(lhs == rhs);
}
std::ostream & operator<<(std::ostream & os, const Vector2 & vector2)
{
return os << vector2.toString();
} | [
"taka.lalpedhuez@2104.gmail.com"
] | taka.lalpedhuez@2104.gmail.com |
8c60bd0247d1b0554d85b59e52a03199eeb26db0 | 7e2abbf295b09d07331402c78bc0df8a242b7e07 | /registration.cpp | 5b39a13a52c3075a1a9d7851af813961810036d6 | [] | no_license | ValeriaGrigoruants/Platform-for-learning-programming | c5f7c1987b2cae830efd62295bad80afb189c632 | 3d1515463c35bd3f4699521125b864c9cbb255b8 | refs/heads/master | 2020-04-14T22:12:47.481531 | 2018-12-04T17:39:07 | 2018-12-04T17:39:07 | 164,154,853 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,533 | cpp | #include "registration.h"
#include "ui_registration.h"
Registration::Registration(QWidget *parent) :
QDialog(parent),
ui(new Ui::Registration)
{
ui->setupUi(this);
QPixmap bkgnd("C:\\Users\\Valeria\\Documents\\LearnProgramming\\back.jpg");
bkgnd = bkgnd.scaled(this->size(), Qt::IgnoreAspectRatio);
QPalette palette;
palette.setBrush(QPalette::Background, bkgnd);
this->setPalette(palette);
}
Registration::~Registration()
{
delete ui;
}
void Registration::on_back_clicked()
{
this -> close();
emit autorization();
}
void Registration::on_registr_clicked()
{
bool flag = false;
QString rx = ui ->namein -> text() + " " + ui -> surnamein -> text();
QFile f("C:\\Users\\Valeria\\Documents\\LearnProgramming\\students.txt");
if (rx.size() > 2)
{
if(f.open(QIODevice::ReadWrite | QIODevice::Text))
{
QString s;
QTextStream t(&f);
while(!t.atEnd())
{
QString line = t.readLine();
if(!line.contains(rx))
{
s.append(line + "\n");
}
else
{
flag = true;
}
}
f.resize(0);
t << s;
f.close();
ui ->namein -> clear();
ui -> surnamein -> clear();
}
if (!flag)
QMessageBox::information(this, "False", "You can't registrate!");
else if (ui -> passwin -> text() == ui -> passw2in -> text())
{
QString information = ui ->loginin -> text() + " " + ui -> passwin -> text();
QCryptographicHash hasher(QCryptographicHash::Keccak_256);
hasher.addData(information.toUtf8());
QFile file ("C:\\Users\\Valeria\\Documents\\LearnProgramming\\users.txt");
if (file.open(QIODevice::Append))
{
file.write(rx.toUtf8() + ": " + hasher.result().toBase64());
file.write("\r\n");
ui -> loginin -> clear();
ui -> passwin -> clear();
ui -> passw2in -> clear();
QMessageBox::information(this, "System", "Registration completed successfully!");
file.close();
this -> close();
emit autorization();
}
}
else
{
QMessageBox::information(this, "System", "Passwords do not match");
}
}
}
| [
"valergrig260857@gmail.com"
] | valergrig260857@gmail.com |
854347ea9a27024c040315bcd56fb9e6a890966a | 9399ec3eb00b048b5a952dcc949b865b82b41f33 | /cpp_fundamentals/data structure/STL/Vector.cpp | 40469395fcfbac6c5f2803aab7ca08f3302a8904 | [] | no_license | CrashedBboy/leetcode | 3c7c9c885cbee7e3c10e7dfc648de74db748bc82 | dacdc11e06a7de8f800999eee410173f8a93d994 | refs/heads/master | 2021-11-08T12:35:00.086370 | 2021-10-12T15:44:02 | 2021-10-12T15:44:02 | 245,770,766 | 4 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 1,841 | cpp | // reference: https://www.cplusplus.com/reference/vector/vector/
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
void printVector(vector<int>& v, string name) {
cout << name << ": [";
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << "]" << endl;
}
int main() {
// [declaration]
int a[] = { 1, 2, 3, 4, 5 };
cout << "size of a[]: " << (sizeof(a) / sizeof(*a)) << endl;
vector<int> vec1(a, a + (sizeof(a) / sizeof(*a)));
printVector(vec1, "vector1");
vector<int> vec2(vec1);
printVector(vec2, "vector2");
vector<int> vec3(vec1.begin(), vec1.end() - 1);
printVector(vec3, "vector3");
vector<int> vec4(5, 12);
printVector(vec4, "vector4");
vector<int> vec5 = { 5, 4, 3, 2, 1 };
printVector(vec5, "Vector5");
// [Access]
cout << "vec1[2] = " << vec1[2] << endl; // O(1)
cout << "vec1.front() = " << vec1.front() << endl; // O(1)
cout << "vec1.back() = " << vec1.back() << endl; // O(1)
// [Capacity]
if ( !vec1.empty() ) { // O(1)
cout << "vec1.size() = " << vec1.size() << endl; // O(1)
}
// [Modifier]
vec1.clear(); // O(N)
printVector(vec1, "(1)vec1");
vec1.push_back(10); // O(1)
vec1.push_back(11);
vec1.push_back(12);
vec1.push_back(13);
vec1.push_back(14);
printVector(vec1, "(2)vec1");
vec1.pop_back(); // O(1)
printVector(vec1, "(3)vec1");
vec1.resize(2); // O(N)
printVector(vec1, "(4)vec1");
vec1.resize(5, 20); // O(N)
printVector(vec1, "(5)vec1");
// defined in header <algorithm>
swap(vec1[0], vec1[1]); // O(1)
printVector(vec1, "(6)vec1");
return 0;
}
// push_back(), pop_back(), begin(), end(), front(), back(), size(), empty(), clear(), resize()
| [
"crashedbboy@gmail.com"
] | crashedbboy@gmail.com |
4c76794b5650d770d4bbd59723abd3077353f0ea | c03615f53093643e3c1e323b83cbe77970966575 | /PRT/3rdParty/cgal/cgal/include/CGAL/RS/rs2_calls.h | 3ed61b4a5887ea774280b12eb2eae7201c331b84 | [] | no_license | fangguanya/PRT | 0925b28671e756a6e9431fd57149cf2eebc94818 | 77c1b8e5f3a7a149825ad0cc3ef6002816222622 | refs/heads/master | 2021-06-08T20:54:22.954395 | 2016-11-24T07:38:11 | 2016-11-24T07:38:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,906 | h | // Copyright (c) 2006-2013 INRIA Nancy-Grand Est (France). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); 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.
// See the file LICENSE.LGPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
// Author: Luis Peñaranda <luis.penaranda@gmx.com>
#ifndef CGAL_RS_RS2_CALLS_H
#define CGAL_RS_RS2_CALLS_H
#include <CGAL/Gmpz.h>
#include <CGAL/Gmpfr.h>
#include <CGAL/Gmpfi.h>
#include <CGAL/Polynomial.h>
#include <rs_exports.h>
#ifdef CGAL_RS_OLD_INCLUDES
#define CGALRS_PTR(a) long int a
#else
#define CGALRS_PTR(a) void *a
#endif
namespace CGAL{
namespace RS2{
struct RS2_calls{
static void init_solver(){
static bool first=true;
if(first){
first=false;
rs_init_rs();
rs_reset_all();
}else
rs_reset_all();
}
static void create_rs_upoly(CGAL::Polynomial<CGAL::Gmpz> poly,
CGALRS_PTR(ident_pol)){
CGALRS_PTR(ident_mon);
CGALRS_PTR(ident_coeff);
rs_import_uppring((char*)"T");
for(int i=0;i<=poly.degree();++i)
if(mpz_sgn(poly[i].mpz())){ // don't add if == 0
ident_mon=rs_export_new_mon_upp_bz();
ident_coeff=rs_export_new_gmp();
rs_import_bz_gmp(ident_coeff,
TO_RSPTR_IN(&(poly[i].mpz())));
rs_dset_mon_upp_bz(ident_mon,ident_coeff,i);
rs_dappend_list_mon_upp_bz(ident_pol,
ident_mon);
}
}
static int affiche_sols_eqs(mpfi_ptr *x){
CGALRS_PTR(ident_sols_eqs);
CGALRS_PTR(ident_node);
CGALRS_PTR(ident_vect);
CGALRS_PTR(ident_elt);
int nb_elts;
ident_sols_eqs=rs_get_default_sols_eqs();
nb_elts=rs_export_list_vect_ibfr_nb(ident_sols_eqs);
ident_node=rs_export_list_vect_ibfr_firstnode(ident_sols_eqs);
mpfi_t *roots=(mpfi_t*)malloc(nb_elts*sizeof(mpfi_t));
for(int i=0;i<nb_elts;++i){
ident_vect=rs_export_list_vect_ibfr_monnode
(ident_node);
CGAL_assertion_msg(rs_export_dim_vect_ibfr
(ident_vect)==1,
"vector dimension must be 1");
ident_elt=rs_export_elt_vect_ibfr(ident_vect,0);
mpfi_ptr root_pointer=
(mpfi_ptr)rs_export_ibfr_mpfi(ident_elt);
mpfi_init2(roots[i],mpfi_get_prec(root_pointer));
mpfi_set(roots[i],root_pointer);
x[i]=roots[i];
// This doesn't work because RS relocates the
// mpfrs that form the mpfi. Nevertheless, the
// mpfi address is not changed.
//x[i]=(mpfi_ptr)rs_export_ibfr_mpfi(ident_elt);
ident_node=rs_export_list_vect_ibfr_nextnode
(ident_node);
}
return nb_elts;
}
template<class OutputIterator>
static OutputIterator insert_roots(OutputIterator x){
CGALRS_PTR(ident_sols_eqs);
CGALRS_PTR(ident_node);
CGALRS_PTR(ident_vect);
CGALRS_PTR(ident_elt);
int nb_elts;
ident_sols_eqs=rs_get_default_sols_eqs();
nb_elts=rs_export_list_vect_ibfr_nb(ident_sols_eqs);
ident_node=rs_export_list_vect_ibfr_firstnode(ident_sols_eqs);
for(int i=0;i<nb_elts;++i){
ident_vect=rs_export_list_vect_ibfr_monnode
(ident_node);
CGAL_assertion_msg(rs_export_dim_vect_ibfr
(ident_vect)==1,
"vector dimension must be 1");
ident_elt=rs_export_elt_vect_ibfr(ident_vect,0);
mpfi_ptr root_pointer=
(mpfi_ptr)rs_export_ibfr_mpfi(ident_elt);
mp_prec_t root_prec=mpfi_get_prec(root_pointer);
// Construct Gmpfr's with pointers to endpoints.
Gmpfr left(&(root_pointer->left),root_prec);
Gmpfr right(&(root_pointer->right),root_prec);
// Copy them, to have the data out of RS memory.
*x++=Gmpfi(left,right,root_prec+1);
ident_node=rs_export_list_vect_ibfr_nextnode
(ident_node);
}
return x;
}
}; // struct RS2_calls
} // namespace RS2
} // namespace CGAL
#endif // CGAL_RS_RS2_CALLS_H
| [
"succeed.2009@163.com"
] | succeed.2009@163.com |
26fd733c9ec81dac0de01cf7c78d596b5876aa83 | c776476e9d06b3779d744641e758ac3a2c15cddc | /examples/litmus/c/run-scripts/tmp_5/R+po-data-wsipl+rfila.c.cbmc_out.cpp | 40d8ed77f78f9d41dee34f2242935713d0d65c1d | [] | no_license | ashutosh0gupta/llvm_bmc | aaac7961c723ba6f7ffd77a39559e0e52432eade | 0287c4fb180244e6b3c599a9902507f05c8a7234 | refs/heads/master | 2023-08-02T17:14:06.178723 | 2023-07-31T10:46:53 | 2023-07-31T10:46:53 | 143,100,825 | 3 | 4 | null | 2023-05-25T05:50:55 | 2018-08-01T03:47:00 | C++ | UTF-8 | C++ | false | false | 42,046 | cpp | // Global variabls:
// 0:vars:2
// 2:atom_0_X6_3:1
// 3:atom_1_X3_4:1
// 4:atom_1_X2_3:1
// Local global variabls:
// 0:thr0:1
// 1:thr1:1
#define ADDRSIZE 5
#define LOCALADDRSIZE 2
#define NTHREAD 3
#define NCONTEXT 5
#define ASSUME(stmt) __CPROVER_assume(stmt)
#define ASSERT(stmt) __CPROVER_assert(stmt, "error")
#define max(a,b) (a>b?a:b)
char __get_rng();
char get_rng( char from, char to ) {
char ret = __get_rng();
ASSUME(ret >= from && ret <= to);
return ret;
}
char get_rng_th( char from, char to ) {
char ret = __get_rng();
ASSUME(ret >= from && ret <= to);
return ret;
}
int main(int argc, char **argv) {
// Declare arrays for intial value version in contexts
int local_mem[LOCALADDRSIZE];
// Dumping initializations
local_mem[0+0] = 0;
local_mem[1+0] = 0;
int cstart[NTHREAD];
int creturn[NTHREAD];
// declare arrays for contexts activity
int active[NCONTEXT];
int ctx_used[NCONTEXT];
// declare arrays for intial value version in contexts
int meminit_[ADDRSIZE*NCONTEXT];
#define meminit(x,k) meminit_[(x)*NCONTEXT+k]
int coinit_[ADDRSIZE*NCONTEXT];
#define coinit(x,k) coinit_[(x)*NCONTEXT+k]
int deltainit_[ADDRSIZE*NCONTEXT];
#define deltainit(x,k) deltainit_[(x)*NCONTEXT+k]
// declare arrays for running value version in contexts
int mem_[ADDRSIZE*NCONTEXT];
#define mem(x,k) mem_[(x)*NCONTEXT+k]
int co_[ADDRSIZE*NCONTEXT];
#define co(x,k) co_[(x)*NCONTEXT+k]
int delta_[ADDRSIZE*NCONTEXT];
#define delta(x,k) delta_[(x)*NCONTEXT+k]
// declare arrays for local buffer and observed writes
int buff_[NTHREAD*ADDRSIZE];
#define buff(x,k) buff_[(x)*ADDRSIZE+k]
int pw_[NTHREAD*ADDRSIZE];
#define pw(x,k) pw_[(x)*ADDRSIZE+k]
// declare arrays for context stamps
char cr_[NTHREAD*ADDRSIZE];
#define cr(x,k) cr_[(x)*ADDRSIZE+k]
char iw_[NTHREAD*ADDRSIZE];
#define iw(x,k) iw_[(x)*ADDRSIZE+k]
char cw_[NTHREAD*ADDRSIZE];
#define cw(x,k) cw_[(x)*ADDRSIZE+k]
char cx_[NTHREAD*ADDRSIZE];
#define cx(x,k) cx_[(x)*ADDRSIZE+k]
char is_[NTHREAD*ADDRSIZE];
#define is(x,k) is_[(x)*ADDRSIZE+k]
char cs_[NTHREAD*ADDRSIZE];
#define cs(x,k) cs_[(x)*ADDRSIZE+k]
char crmax_[NTHREAD*ADDRSIZE];
#define crmax(x,k) crmax_[(x)*ADDRSIZE+k]
char sforbid_[ADDRSIZE*NCONTEXT];
#define sforbid(x,k) sforbid_[(x)*NCONTEXT+k]
// declare arrays for synchronizations
int cl[NTHREAD];
int cdy[NTHREAD];
int cds[NTHREAD];
int cdl[NTHREAD];
int cisb[NTHREAD];
int caddr[NTHREAD];
int cctrl[NTHREAD];
int r0= 0;
char creg_r0;
int r1= 0;
char creg_r1;
int r2= 0;
char creg_r2;
int r3= 0;
char creg_r3;
char creg__r3__3_;
int r4= 0;
char creg_r4;
int r5= 0;
char creg_r5;
char creg__r5__4_;
char creg__r4__3_;
int r6= 0;
char creg_r6;
int r7= 0;
char creg_r7;
int r8= 0;
char creg_r8;
int r9= 0;
char creg_r9;
char creg__r9__4_;
int r10= 0;
char creg_r10;
int r11= 0;
char creg_r11;
int r12= 0;
char creg_r12;
int r13= 0;
char creg_r13;
int r14= 0;
char creg_r14;
int r15= 0;
char creg_r15;
char creg__r15__1_;
int r16= 0;
char creg_r16;
char old_cctrl= 0;
char old_cr= 0;
char old_cdy= 0;
char old_cw= 0;
char new_creg= 0;
buff(0,0) = 0;
pw(0,0) = 0;
cr(0,0) = 0;
iw(0,0) = 0;
cw(0,0) = 0;
cx(0,0) = 0;
is(0,0) = 0;
cs(0,0) = 0;
crmax(0,0) = 0;
buff(0,1) = 0;
pw(0,1) = 0;
cr(0,1) = 0;
iw(0,1) = 0;
cw(0,1) = 0;
cx(0,1) = 0;
is(0,1) = 0;
cs(0,1) = 0;
crmax(0,1) = 0;
buff(0,2) = 0;
pw(0,2) = 0;
cr(0,2) = 0;
iw(0,2) = 0;
cw(0,2) = 0;
cx(0,2) = 0;
is(0,2) = 0;
cs(0,2) = 0;
crmax(0,2) = 0;
buff(0,3) = 0;
pw(0,3) = 0;
cr(0,3) = 0;
iw(0,3) = 0;
cw(0,3) = 0;
cx(0,3) = 0;
is(0,3) = 0;
cs(0,3) = 0;
crmax(0,3) = 0;
buff(0,4) = 0;
pw(0,4) = 0;
cr(0,4) = 0;
iw(0,4) = 0;
cw(0,4) = 0;
cx(0,4) = 0;
is(0,4) = 0;
cs(0,4) = 0;
crmax(0,4) = 0;
cl[0] = 0;
cdy[0] = 0;
cds[0] = 0;
cdl[0] = 0;
cisb[0] = 0;
caddr[0] = 0;
cctrl[0] = 0;
cstart[0] = get_rng(0,NCONTEXT-1);
creturn[0] = get_rng(0,NCONTEXT-1);
buff(1,0) = 0;
pw(1,0) = 0;
cr(1,0) = 0;
iw(1,0) = 0;
cw(1,0) = 0;
cx(1,0) = 0;
is(1,0) = 0;
cs(1,0) = 0;
crmax(1,0) = 0;
buff(1,1) = 0;
pw(1,1) = 0;
cr(1,1) = 0;
iw(1,1) = 0;
cw(1,1) = 0;
cx(1,1) = 0;
is(1,1) = 0;
cs(1,1) = 0;
crmax(1,1) = 0;
buff(1,2) = 0;
pw(1,2) = 0;
cr(1,2) = 0;
iw(1,2) = 0;
cw(1,2) = 0;
cx(1,2) = 0;
is(1,2) = 0;
cs(1,2) = 0;
crmax(1,2) = 0;
buff(1,3) = 0;
pw(1,3) = 0;
cr(1,3) = 0;
iw(1,3) = 0;
cw(1,3) = 0;
cx(1,3) = 0;
is(1,3) = 0;
cs(1,3) = 0;
crmax(1,3) = 0;
buff(1,4) = 0;
pw(1,4) = 0;
cr(1,4) = 0;
iw(1,4) = 0;
cw(1,4) = 0;
cx(1,4) = 0;
is(1,4) = 0;
cs(1,4) = 0;
crmax(1,4) = 0;
cl[1] = 0;
cdy[1] = 0;
cds[1] = 0;
cdl[1] = 0;
cisb[1] = 0;
caddr[1] = 0;
cctrl[1] = 0;
cstart[1] = get_rng(0,NCONTEXT-1);
creturn[1] = get_rng(0,NCONTEXT-1);
buff(2,0) = 0;
pw(2,0) = 0;
cr(2,0) = 0;
iw(2,0) = 0;
cw(2,0) = 0;
cx(2,0) = 0;
is(2,0) = 0;
cs(2,0) = 0;
crmax(2,0) = 0;
buff(2,1) = 0;
pw(2,1) = 0;
cr(2,1) = 0;
iw(2,1) = 0;
cw(2,1) = 0;
cx(2,1) = 0;
is(2,1) = 0;
cs(2,1) = 0;
crmax(2,1) = 0;
buff(2,2) = 0;
pw(2,2) = 0;
cr(2,2) = 0;
iw(2,2) = 0;
cw(2,2) = 0;
cx(2,2) = 0;
is(2,2) = 0;
cs(2,2) = 0;
crmax(2,2) = 0;
buff(2,3) = 0;
pw(2,3) = 0;
cr(2,3) = 0;
iw(2,3) = 0;
cw(2,3) = 0;
cx(2,3) = 0;
is(2,3) = 0;
cs(2,3) = 0;
crmax(2,3) = 0;
buff(2,4) = 0;
pw(2,4) = 0;
cr(2,4) = 0;
iw(2,4) = 0;
cw(2,4) = 0;
cx(2,4) = 0;
is(2,4) = 0;
cs(2,4) = 0;
crmax(2,4) = 0;
cl[2] = 0;
cdy[2] = 0;
cds[2] = 0;
cdl[2] = 0;
cisb[2] = 0;
caddr[2] = 0;
cctrl[2] = 0;
cstart[2] = get_rng(0,NCONTEXT-1);
creturn[2] = get_rng(0,NCONTEXT-1);
// Dumping initializations
mem(0+0,0) = 0;
mem(0+1,0) = 0;
mem(2+0,0) = 0;
mem(3+0,0) = 0;
mem(4+0,0) = 0;
// Dumping context matching equalities
co(0,0) = 0;
delta(0,0) = -1;
mem(0,1) = meminit(0,1);
co(0,1) = coinit(0,1);
delta(0,1) = deltainit(0,1);
mem(0,2) = meminit(0,2);
co(0,2) = coinit(0,2);
delta(0,2) = deltainit(0,2);
mem(0,3) = meminit(0,3);
co(0,3) = coinit(0,3);
delta(0,3) = deltainit(0,3);
mem(0,4) = meminit(0,4);
co(0,4) = coinit(0,4);
delta(0,4) = deltainit(0,4);
co(1,0) = 0;
delta(1,0) = -1;
mem(1,1) = meminit(1,1);
co(1,1) = coinit(1,1);
delta(1,1) = deltainit(1,1);
mem(1,2) = meminit(1,2);
co(1,2) = coinit(1,2);
delta(1,2) = deltainit(1,2);
mem(1,3) = meminit(1,3);
co(1,3) = coinit(1,3);
delta(1,3) = deltainit(1,3);
mem(1,4) = meminit(1,4);
co(1,4) = coinit(1,4);
delta(1,4) = deltainit(1,4);
co(2,0) = 0;
delta(2,0) = -1;
mem(2,1) = meminit(2,1);
co(2,1) = coinit(2,1);
delta(2,1) = deltainit(2,1);
mem(2,2) = meminit(2,2);
co(2,2) = coinit(2,2);
delta(2,2) = deltainit(2,2);
mem(2,3) = meminit(2,3);
co(2,3) = coinit(2,3);
delta(2,3) = deltainit(2,3);
mem(2,4) = meminit(2,4);
co(2,4) = coinit(2,4);
delta(2,4) = deltainit(2,4);
co(3,0) = 0;
delta(3,0) = -1;
mem(3,1) = meminit(3,1);
co(3,1) = coinit(3,1);
delta(3,1) = deltainit(3,1);
mem(3,2) = meminit(3,2);
co(3,2) = coinit(3,2);
delta(3,2) = deltainit(3,2);
mem(3,3) = meminit(3,3);
co(3,3) = coinit(3,3);
delta(3,3) = deltainit(3,3);
mem(3,4) = meminit(3,4);
co(3,4) = coinit(3,4);
delta(3,4) = deltainit(3,4);
co(4,0) = 0;
delta(4,0) = -1;
mem(4,1) = meminit(4,1);
co(4,1) = coinit(4,1);
delta(4,1) = deltainit(4,1);
mem(4,2) = meminit(4,2);
co(4,2) = coinit(4,2);
delta(4,2) = deltainit(4,2);
mem(4,3) = meminit(4,3);
co(4,3) = coinit(4,3);
delta(4,3) = deltainit(4,3);
mem(4,4) = meminit(4,4);
co(4,4) = coinit(4,4);
delta(4,4) = deltainit(4,4);
// Dumping thread 1
int ret_thread_1 = 0;
cdy[1] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[1] >= cstart[1]);
T1BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !38, metadata !DIExpression()), !dbg !61
// br label %label_1, !dbg !62
goto T1BLOCK1;
T1BLOCK1:
// call void @llvm.dbg.label(metadata !60), !dbg !63
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !39, metadata !DIExpression()), !dbg !64
// call void @llvm.dbg.value(metadata i64 4, metadata !42, metadata !DIExpression()), !dbg !64
// store atomic i64 4, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !65
// ST: Guess
iw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STIW _l21_c3
old_cw = cw(1,0);
cw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STCOM _l21_c3
// Check
ASSUME(active[iw(1,0)] == 1);
ASSUME(active[cw(1,0)] == 1);
ASSUME(sforbid(0,cw(1,0))== 0);
ASSUME(iw(1,0) >= 0);
ASSUME(iw(1,0) >= 0);
ASSUME(cw(1,0) >= iw(1,0));
ASSUME(cw(1,0) >= old_cw);
ASSUME(cw(1,0) >= cr(1,0));
ASSUME(cw(1,0) >= cl[1]);
ASSUME(cw(1,0) >= cisb[1]);
ASSUME(cw(1,0) >= cdy[1]);
ASSUME(cw(1,0) >= cdl[1]);
ASSUME(cw(1,0) >= cds[1]);
ASSUME(cw(1,0) >= cctrl[1]);
ASSUME(cw(1,0) >= caddr[1]);
// Update
caddr[1] = max(caddr[1],0);
buff(1,0) = 4;
mem(0,cw(1,0)) = 4;
co(0,cw(1,0))+=1;
delta(0,cw(1,0)) = -1;
ASSUME(creturn[1] >= cw(1,0));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1), metadata !44, metadata !DIExpression()), !dbg !66
// %0 = load atomic i64, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !67
// LD: Guess
old_cr = cr(1,0+1*1);
cr(1,0+1*1) = get_rng(0,NCONTEXT-1);// 1 ASSIGN LDCOM _l22_c15
// Check
ASSUME(active[cr(1,0+1*1)] == 1);
ASSUME(cr(1,0+1*1) >= iw(1,0+1*1));
ASSUME(cr(1,0+1*1) >= 0);
ASSUME(cr(1,0+1*1) >= cdy[1]);
ASSUME(cr(1,0+1*1) >= cisb[1]);
ASSUME(cr(1,0+1*1) >= cdl[1]);
ASSUME(cr(1,0+1*1) >= cl[1]);
// Update
creg_r0 = cr(1,0+1*1);
crmax(1,0+1*1) = max(crmax(1,0+1*1),cr(1,0+1*1));
caddr[1] = max(caddr[1],0);
if(cr(1,0+1*1) < cw(1,0+1*1)) {
r0 = buff(1,0+1*1);
ASSUME((!(( (cw(1,0+1*1) < 1) && (1 < crmax(1,0+1*1)) )))||(sforbid(0+1*1,1)> 0));
ASSUME((!(( (cw(1,0+1*1) < 2) && (2 < crmax(1,0+1*1)) )))||(sforbid(0+1*1,2)> 0));
ASSUME((!(( (cw(1,0+1*1) < 3) && (3 < crmax(1,0+1*1)) )))||(sforbid(0+1*1,3)> 0));
ASSUME((!(( (cw(1,0+1*1) < 4) && (4 < crmax(1,0+1*1)) )))||(sforbid(0+1*1,4)> 0));
} else {
if(pw(1,0+1*1) != co(0+1*1,cr(1,0+1*1))) {
ASSUME(cr(1,0+1*1) >= old_cr);
}
pw(1,0+1*1) = co(0+1*1,cr(1,0+1*1));
r0 = mem(0+1*1,cr(1,0+1*1));
}
ASSUME(creturn[1] >= cr(1,0+1*1));
// call void @llvm.dbg.value(metadata i64 %0, metadata !46, metadata !DIExpression()), !dbg !66
// %conv = trunc i64 %0 to i32, !dbg !68
// call void @llvm.dbg.value(metadata i32 %conv, metadata !43, metadata !DIExpression()), !dbg !61
// %xor = xor i32 %conv, %conv, !dbg !69
creg_r1 = creg_r0;
r1 = r0 ^ r0;
// call void @llvm.dbg.value(metadata i32 %xor, metadata !47, metadata !DIExpression()), !dbg !61
// %add = add nsw i32 %xor, 1, !dbg !70
creg_r2 = max(0,creg_r1);
r2 = r1 + 1;
// call void @llvm.dbg.value(metadata i32 %add, metadata !48, metadata !DIExpression()), !dbg !61
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !49, metadata !DIExpression()), !dbg !71
// %conv3 = sext i32 %add to i64, !dbg !72
// call void @llvm.dbg.value(metadata i64 %conv3, metadata !51, metadata !DIExpression()), !dbg !71
// store atomic i64 %conv3, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !72
// ST: Guess
iw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STIW _l25_c3
old_cw = cw(1,0);
cw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STCOM _l25_c3
// Check
ASSUME(active[iw(1,0)] == 1);
ASSUME(active[cw(1,0)] == 1);
ASSUME(sforbid(0,cw(1,0))== 0);
ASSUME(iw(1,0) >= creg_r2);
ASSUME(iw(1,0) >= 0);
ASSUME(cw(1,0) >= iw(1,0));
ASSUME(cw(1,0) >= old_cw);
ASSUME(cw(1,0) >= cr(1,0));
ASSUME(cw(1,0) >= cl[1]);
ASSUME(cw(1,0) >= cisb[1]);
ASSUME(cw(1,0) >= cdy[1]);
ASSUME(cw(1,0) >= cdl[1]);
ASSUME(cw(1,0) >= cds[1]);
ASSUME(cw(1,0) >= cctrl[1]);
ASSUME(cw(1,0) >= caddr[1]);
// Update
caddr[1] = max(caddr[1],0);
buff(1,0) = r2;
mem(0,cw(1,0)) = r2;
co(0,cw(1,0))+=1;
delta(0,cw(1,0)) = -1;
ASSUME(creturn[1] >= cw(1,0));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !52, metadata !DIExpression()), !dbg !73
// call void @llvm.dbg.value(metadata i64 2, metadata !54, metadata !DIExpression()), !dbg !73
// store atomic i64 2, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) release, align 8, !dbg !74
// ST: Guess
// : Release
iw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STIW _l26_c3
old_cw = cw(1,0);
cw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STCOM _l26_c3
// Check
ASSUME(active[iw(1,0)] == 1);
ASSUME(active[cw(1,0)] == 1);
ASSUME(sforbid(0,cw(1,0))== 0);
ASSUME(iw(1,0) >= 0);
ASSUME(iw(1,0) >= 0);
ASSUME(cw(1,0) >= iw(1,0));
ASSUME(cw(1,0) >= old_cw);
ASSUME(cw(1,0) >= cr(1,0));
ASSUME(cw(1,0) >= cl[1]);
ASSUME(cw(1,0) >= cisb[1]);
ASSUME(cw(1,0) >= cdy[1]);
ASSUME(cw(1,0) >= cdl[1]);
ASSUME(cw(1,0) >= cds[1]);
ASSUME(cw(1,0) >= cctrl[1]);
ASSUME(cw(1,0) >= caddr[1]);
ASSUME(cw(1,0) >= cr(1,0+0));
ASSUME(cw(1,0) >= cr(1,0+1));
ASSUME(cw(1,0) >= cr(1,2+0));
ASSUME(cw(1,0) >= cr(1,3+0));
ASSUME(cw(1,0) >= cr(1,4+0));
ASSUME(cw(1,0) >= cw(1,0+0));
ASSUME(cw(1,0) >= cw(1,0+1));
ASSUME(cw(1,0) >= cw(1,2+0));
ASSUME(cw(1,0) >= cw(1,3+0));
ASSUME(cw(1,0) >= cw(1,4+0));
// Update
caddr[1] = max(caddr[1],0);
buff(1,0) = 2;
mem(0,cw(1,0)) = 2;
co(0,cw(1,0))+=1;
delta(0,cw(1,0)) = -1;
is(1,0) = iw(1,0);
cs(1,0) = cw(1,0);
ASSUME(creturn[1] >= cw(1,0));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !56, metadata !DIExpression()), !dbg !75
// %1 = load atomic i64, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !76
// LD: Guess
old_cr = cr(1,0);
cr(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN LDCOM _l27_c15
// Check
ASSUME(active[cr(1,0)] == 1);
ASSUME(cr(1,0) >= iw(1,0));
ASSUME(cr(1,0) >= 0);
ASSUME(cr(1,0) >= cdy[1]);
ASSUME(cr(1,0) >= cisb[1]);
ASSUME(cr(1,0) >= cdl[1]);
ASSUME(cr(1,0) >= cl[1]);
// Update
creg_r3 = cr(1,0);
crmax(1,0) = max(crmax(1,0),cr(1,0));
caddr[1] = max(caddr[1],0);
if(cr(1,0) < cw(1,0)) {
r3 = buff(1,0);
ASSUME((!(( (cw(1,0) < 1) && (1 < crmax(1,0)) )))||(sforbid(0,1)> 0));
ASSUME((!(( (cw(1,0) < 2) && (2 < crmax(1,0)) )))||(sforbid(0,2)> 0));
ASSUME((!(( (cw(1,0) < 3) && (3 < crmax(1,0)) )))||(sforbid(0,3)> 0));
ASSUME((!(( (cw(1,0) < 4) && (4 < crmax(1,0)) )))||(sforbid(0,4)> 0));
} else {
if(pw(1,0) != co(0,cr(1,0))) {
ASSUME(cr(1,0) >= old_cr);
}
pw(1,0) = co(0,cr(1,0));
r3 = mem(0,cr(1,0));
}
ASSUME(creturn[1] >= cr(1,0));
// call void @llvm.dbg.value(metadata i64 %1, metadata !58, metadata !DIExpression()), !dbg !75
// %conv9 = trunc i64 %1 to i32, !dbg !77
// call void @llvm.dbg.value(metadata i32 %conv9, metadata !55, metadata !DIExpression()), !dbg !61
// %cmp = icmp eq i32 %conv9, 3, !dbg !78
creg__r3__3_ = max(0,creg_r3);
// %conv10 = zext i1 %cmp to i32, !dbg !78
// call void @llvm.dbg.value(metadata i32 %conv10, metadata !59, metadata !DIExpression()), !dbg !61
// store i32 %conv10, i32* @atom_0_X6_3, align 4, !dbg !79, !tbaa !80
// ST: Guess
iw(1,2) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STIW _l29_c15
old_cw = cw(1,2);
cw(1,2) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STCOM _l29_c15
// Check
ASSUME(active[iw(1,2)] == 1);
ASSUME(active[cw(1,2)] == 1);
ASSUME(sforbid(2,cw(1,2))== 0);
ASSUME(iw(1,2) >= creg__r3__3_);
ASSUME(iw(1,2) >= 0);
ASSUME(cw(1,2) >= iw(1,2));
ASSUME(cw(1,2) >= old_cw);
ASSUME(cw(1,2) >= cr(1,2));
ASSUME(cw(1,2) >= cl[1]);
ASSUME(cw(1,2) >= cisb[1]);
ASSUME(cw(1,2) >= cdy[1]);
ASSUME(cw(1,2) >= cdl[1]);
ASSUME(cw(1,2) >= cds[1]);
ASSUME(cw(1,2) >= cctrl[1]);
ASSUME(cw(1,2) >= caddr[1]);
// Update
caddr[1] = max(caddr[1],0);
buff(1,2) = (r3==3);
mem(2,cw(1,2)) = (r3==3);
co(2,cw(1,2))+=1;
delta(2,cw(1,2)) = -1;
ASSUME(creturn[1] >= cw(1,2));
// ret i8* null, !dbg !84
ret_thread_1 = (- 1);
goto T1BLOCK_END;
T1BLOCK_END:
// Dumping thread 2
int ret_thread_2 = 0;
cdy[2] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[2] >= cstart[2]);
T2BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !87, metadata !DIExpression()), !dbg !102
// br label %label_2, !dbg !55
goto T2BLOCK1;
T2BLOCK1:
// call void @llvm.dbg.label(metadata !101), !dbg !104
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !88, metadata !DIExpression()), !dbg !105
// call void @llvm.dbg.value(metadata i64 3, metadata !90, metadata !DIExpression()), !dbg !105
// store atomic i64 3, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) release, align 8, !dbg !58
// ST: Guess
// : Release
iw(2,0) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW _l35_c3
old_cw = cw(2,0);
cw(2,0) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM _l35_c3
// Check
ASSUME(active[iw(2,0)] == 2);
ASSUME(active[cw(2,0)] == 2);
ASSUME(sforbid(0,cw(2,0))== 0);
ASSUME(iw(2,0) >= 0);
ASSUME(iw(2,0) >= 0);
ASSUME(cw(2,0) >= iw(2,0));
ASSUME(cw(2,0) >= old_cw);
ASSUME(cw(2,0) >= cr(2,0));
ASSUME(cw(2,0) >= cl[2]);
ASSUME(cw(2,0) >= cisb[2]);
ASSUME(cw(2,0) >= cdy[2]);
ASSUME(cw(2,0) >= cdl[2]);
ASSUME(cw(2,0) >= cds[2]);
ASSUME(cw(2,0) >= cctrl[2]);
ASSUME(cw(2,0) >= caddr[2]);
ASSUME(cw(2,0) >= cr(2,0+0));
ASSUME(cw(2,0) >= cr(2,0+1));
ASSUME(cw(2,0) >= cr(2,2+0));
ASSUME(cw(2,0) >= cr(2,3+0));
ASSUME(cw(2,0) >= cr(2,4+0));
ASSUME(cw(2,0) >= cw(2,0+0));
ASSUME(cw(2,0) >= cw(2,0+1));
ASSUME(cw(2,0) >= cw(2,2+0));
ASSUME(cw(2,0) >= cw(2,3+0));
ASSUME(cw(2,0) >= cw(2,4+0));
// Update
caddr[2] = max(caddr[2],0);
buff(2,0) = 3;
mem(0,cw(2,0)) = 3;
co(0,cw(2,0))+=1;
delta(0,cw(2,0)) = -1;
is(2,0) = iw(2,0);
cs(2,0) = cw(2,0);
ASSUME(creturn[2] >= cw(2,0));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !92, metadata !DIExpression()), !dbg !107
// %0 = load atomic i64, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) acquire, align 8, !dbg !60
// LD: Guess
// : Acquire
old_cr = cr(2,0);
cr(2,0) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM _l36_c16
// Check
ASSUME(active[cr(2,0)] == 2);
ASSUME(cr(2,0) >= iw(2,0));
ASSUME(cr(2,0) >= 0);
ASSUME(cr(2,0) >= cdy[2]);
ASSUME(cr(2,0) >= cisb[2]);
ASSUME(cr(2,0) >= cdl[2]);
ASSUME(cr(2,0) >= cl[2]);
ASSUME(cr(2,0) >= cx(2,0));
ASSUME(cr(2,0) >= cs(2,0+0));
ASSUME(cr(2,0) >= cs(2,0+1));
ASSUME(cr(2,0) >= cs(2,2+0));
ASSUME(cr(2,0) >= cs(2,3+0));
ASSUME(cr(2,0) >= cs(2,4+0));
// Update
creg_r4 = cr(2,0);
crmax(2,0) = max(crmax(2,0),cr(2,0));
caddr[2] = max(caddr[2],0);
if(cr(2,0) < cw(2,0)) {
r4 = buff(2,0);
ASSUME((!(( (cw(2,0) < 1) && (1 < crmax(2,0)) )))||(sforbid(0,1)> 0));
ASSUME((!(( (cw(2,0) < 2) && (2 < crmax(2,0)) )))||(sforbid(0,2)> 0));
ASSUME((!(( (cw(2,0) < 3) && (3 < crmax(2,0)) )))||(sforbid(0,3)> 0));
ASSUME((!(( (cw(2,0) < 4) && (4 < crmax(2,0)) )))||(sforbid(0,4)> 0));
} else {
if(pw(2,0) != co(0,cr(2,0))) {
ASSUME(cr(2,0) >= old_cr);
}
pw(2,0) = co(0,cr(2,0));
r4 = mem(0,cr(2,0));
}
cl[2] = max(cl[2],cr(2,0));
ASSUME(creturn[2] >= cr(2,0));
// call void @llvm.dbg.value(metadata i64 %0, metadata !94, metadata !DIExpression()), !dbg !107
// %conv = trunc i64 %0 to i32, !dbg !61
// call void @llvm.dbg.value(metadata i32 %conv, metadata !91, metadata !DIExpression()), !dbg !102
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !96, metadata !DIExpression()), !dbg !110
// %1 = load atomic i64, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !63
// LD: Guess
old_cr = cr(2,0);
cr(2,0) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM _l37_c16
// Check
ASSUME(active[cr(2,0)] == 2);
ASSUME(cr(2,0) >= iw(2,0));
ASSUME(cr(2,0) >= 0);
ASSUME(cr(2,0) >= cdy[2]);
ASSUME(cr(2,0) >= cisb[2]);
ASSUME(cr(2,0) >= cdl[2]);
ASSUME(cr(2,0) >= cl[2]);
// Update
creg_r5 = cr(2,0);
crmax(2,0) = max(crmax(2,0),cr(2,0));
caddr[2] = max(caddr[2],0);
if(cr(2,0) < cw(2,0)) {
r5 = buff(2,0);
ASSUME((!(( (cw(2,0) < 1) && (1 < crmax(2,0)) )))||(sforbid(0,1)> 0));
ASSUME((!(( (cw(2,0) < 2) && (2 < crmax(2,0)) )))||(sforbid(0,2)> 0));
ASSUME((!(( (cw(2,0) < 3) && (3 < crmax(2,0)) )))||(sforbid(0,3)> 0));
ASSUME((!(( (cw(2,0) < 4) && (4 < crmax(2,0)) )))||(sforbid(0,4)> 0));
} else {
if(pw(2,0) != co(0,cr(2,0))) {
ASSUME(cr(2,0) >= old_cr);
}
pw(2,0) = co(0,cr(2,0));
r5 = mem(0,cr(2,0));
}
ASSUME(creturn[2] >= cr(2,0));
// call void @llvm.dbg.value(metadata i64 %1, metadata !98, metadata !DIExpression()), !dbg !110
// %conv4 = trunc i64 %1 to i32, !dbg !64
// call void @llvm.dbg.value(metadata i32 %conv4, metadata !95, metadata !DIExpression()), !dbg !102
// %cmp = icmp eq i32 %conv4, 4, !dbg !65
creg__r5__4_ = max(0,creg_r5);
// %conv5 = zext i1 %cmp to i32, !dbg !65
// call void @llvm.dbg.value(metadata i32 %conv5, metadata !99, metadata !DIExpression()), !dbg !102
// store i32 %conv5, i32* @atom_1_X3_4, align 4, !dbg !66, !tbaa !67
// ST: Guess
iw(2,3) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW _l39_c15
old_cw = cw(2,3);
cw(2,3) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM _l39_c15
// Check
ASSUME(active[iw(2,3)] == 2);
ASSUME(active[cw(2,3)] == 2);
ASSUME(sforbid(3,cw(2,3))== 0);
ASSUME(iw(2,3) >= creg__r5__4_);
ASSUME(iw(2,3) >= 0);
ASSUME(cw(2,3) >= iw(2,3));
ASSUME(cw(2,3) >= old_cw);
ASSUME(cw(2,3) >= cr(2,3));
ASSUME(cw(2,3) >= cl[2]);
ASSUME(cw(2,3) >= cisb[2]);
ASSUME(cw(2,3) >= cdy[2]);
ASSUME(cw(2,3) >= cdl[2]);
ASSUME(cw(2,3) >= cds[2]);
ASSUME(cw(2,3) >= cctrl[2]);
ASSUME(cw(2,3) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,3) = (r5==4);
mem(3,cw(2,3)) = (r5==4);
co(3,cw(2,3))+=1;
delta(3,cw(2,3)) = -1;
ASSUME(creturn[2] >= cw(2,3));
// %cmp6 = icmp eq i32 %conv, 3, !dbg !71
creg__r4__3_ = max(0,creg_r4);
// %conv7 = zext i1 %cmp6 to i32, !dbg !71
// call void @llvm.dbg.value(metadata i32 %conv7, metadata !100, metadata !DIExpression()), !dbg !102
// store i32 %conv7, i32* @atom_1_X2_3, align 4, !dbg !72, !tbaa !67
// ST: Guess
iw(2,4) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW _l41_c15
old_cw = cw(2,4);
cw(2,4) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM _l41_c15
// Check
ASSUME(active[iw(2,4)] == 2);
ASSUME(active[cw(2,4)] == 2);
ASSUME(sforbid(4,cw(2,4))== 0);
ASSUME(iw(2,4) >= creg__r4__3_);
ASSUME(iw(2,4) >= 0);
ASSUME(cw(2,4) >= iw(2,4));
ASSUME(cw(2,4) >= old_cw);
ASSUME(cw(2,4) >= cr(2,4));
ASSUME(cw(2,4) >= cl[2]);
ASSUME(cw(2,4) >= cisb[2]);
ASSUME(cw(2,4) >= cdy[2]);
ASSUME(cw(2,4) >= cdl[2]);
ASSUME(cw(2,4) >= cds[2]);
ASSUME(cw(2,4) >= cctrl[2]);
ASSUME(cw(2,4) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,4) = (r4==3);
mem(4,cw(2,4)) = (r4==3);
co(4,cw(2,4))+=1;
delta(4,cw(2,4)) = -1;
ASSUME(creturn[2] >= cw(2,4));
// ret i8* null, !dbg !73
ret_thread_2 = (- 1);
goto T2BLOCK_END;
T2BLOCK_END:
// Dumping thread 0
int ret_thread_0 = 0;
cdy[0] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[0] >= cstart[0]);
T0BLOCK0:
// %thr0 = alloca i64, align 8
// %thr1 = alloca i64, align 8
// call void @llvm.dbg.value(metadata i32 %argc, metadata !125, metadata !DIExpression()), !dbg !149
// call void @llvm.dbg.value(metadata i8** %argv, metadata !126, metadata !DIExpression()), !dbg !149
// %0 = bitcast i64* %thr0 to i8*, !dbg !67
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %0) #7, !dbg !67
// call void @llvm.dbg.declare(metadata i64* %thr0, metadata !127, metadata !DIExpression()), !dbg !151
// %1 = bitcast i64* %thr1 to i8*, !dbg !69
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %1) #7, !dbg !69
// call void @llvm.dbg.declare(metadata i64* %thr1, metadata !131, metadata !DIExpression()), !dbg !153
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1), metadata !132, metadata !DIExpression()), !dbg !154
// call void @llvm.dbg.value(metadata i64 0, metadata !134, metadata !DIExpression()), !dbg !154
// store atomic i64 0, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !72
// ST: Guess
iw(0,0+1*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l49_c3
old_cw = cw(0,0+1*1);
cw(0,0+1*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l49_c3
// Check
ASSUME(active[iw(0,0+1*1)] == 0);
ASSUME(active[cw(0,0+1*1)] == 0);
ASSUME(sforbid(0+1*1,cw(0,0+1*1))== 0);
ASSUME(iw(0,0+1*1) >= 0);
ASSUME(iw(0,0+1*1) >= 0);
ASSUME(cw(0,0+1*1) >= iw(0,0+1*1));
ASSUME(cw(0,0+1*1) >= old_cw);
ASSUME(cw(0,0+1*1) >= cr(0,0+1*1));
ASSUME(cw(0,0+1*1) >= cl[0]);
ASSUME(cw(0,0+1*1) >= cisb[0]);
ASSUME(cw(0,0+1*1) >= cdy[0]);
ASSUME(cw(0,0+1*1) >= cdl[0]);
ASSUME(cw(0,0+1*1) >= cds[0]);
ASSUME(cw(0,0+1*1) >= cctrl[0]);
ASSUME(cw(0,0+1*1) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,0+1*1) = 0;
mem(0+1*1,cw(0,0+1*1)) = 0;
co(0+1*1,cw(0,0+1*1))+=1;
delta(0+1*1,cw(0,0+1*1)) = -1;
ASSUME(creturn[0] >= cw(0,0+1*1));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !135, metadata !DIExpression()), !dbg !156
// call void @llvm.dbg.value(metadata i64 0, metadata !137, metadata !DIExpression()), !dbg !156
// store atomic i64 0, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !74
// ST: Guess
iw(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l50_c3
old_cw = cw(0,0);
cw(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l50_c3
// Check
ASSUME(active[iw(0,0)] == 0);
ASSUME(active[cw(0,0)] == 0);
ASSUME(sforbid(0,cw(0,0))== 0);
ASSUME(iw(0,0) >= 0);
ASSUME(iw(0,0) >= 0);
ASSUME(cw(0,0) >= iw(0,0));
ASSUME(cw(0,0) >= old_cw);
ASSUME(cw(0,0) >= cr(0,0));
ASSUME(cw(0,0) >= cl[0]);
ASSUME(cw(0,0) >= cisb[0]);
ASSUME(cw(0,0) >= cdy[0]);
ASSUME(cw(0,0) >= cdl[0]);
ASSUME(cw(0,0) >= cds[0]);
ASSUME(cw(0,0) >= cctrl[0]);
ASSUME(cw(0,0) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,0) = 0;
mem(0,cw(0,0)) = 0;
co(0,cw(0,0))+=1;
delta(0,cw(0,0)) = -1;
ASSUME(creturn[0] >= cw(0,0));
// store i32 0, i32* @atom_0_X6_3, align 4, !dbg !75, !tbaa !76
// ST: Guess
iw(0,2) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l51_c15
old_cw = cw(0,2);
cw(0,2) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l51_c15
// Check
ASSUME(active[iw(0,2)] == 0);
ASSUME(active[cw(0,2)] == 0);
ASSUME(sforbid(2,cw(0,2))== 0);
ASSUME(iw(0,2) >= 0);
ASSUME(iw(0,2) >= 0);
ASSUME(cw(0,2) >= iw(0,2));
ASSUME(cw(0,2) >= old_cw);
ASSUME(cw(0,2) >= cr(0,2));
ASSUME(cw(0,2) >= cl[0]);
ASSUME(cw(0,2) >= cisb[0]);
ASSUME(cw(0,2) >= cdy[0]);
ASSUME(cw(0,2) >= cdl[0]);
ASSUME(cw(0,2) >= cds[0]);
ASSUME(cw(0,2) >= cctrl[0]);
ASSUME(cw(0,2) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,2) = 0;
mem(2,cw(0,2)) = 0;
co(2,cw(0,2))+=1;
delta(2,cw(0,2)) = -1;
ASSUME(creturn[0] >= cw(0,2));
// store i32 0, i32* @atom_1_X3_4, align 4, !dbg !80, !tbaa !76
// ST: Guess
iw(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l52_c15
old_cw = cw(0,3);
cw(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l52_c15
// Check
ASSUME(active[iw(0,3)] == 0);
ASSUME(active[cw(0,3)] == 0);
ASSUME(sforbid(3,cw(0,3))== 0);
ASSUME(iw(0,3) >= 0);
ASSUME(iw(0,3) >= 0);
ASSUME(cw(0,3) >= iw(0,3));
ASSUME(cw(0,3) >= old_cw);
ASSUME(cw(0,3) >= cr(0,3));
ASSUME(cw(0,3) >= cl[0]);
ASSUME(cw(0,3) >= cisb[0]);
ASSUME(cw(0,3) >= cdy[0]);
ASSUME(cw(0,3) >= cdl[0]);
ASSUME(cw(0,3) >= cds[0]);
ASSUME(cw(0,3) >= cctrl[0]);
ASSUME(cw(0,3) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,3) = 0;
mem(3,cw(0,3)) = 0;
co(3,cw(0,3))+=1;
delta(3,cw(0,3)) = -1;
ASSUME(creturn[0] >= cw(0,3));
// store i32 0, i32* @atom_1_X2_3, align 4, !dbg !81, !tbaa !76
// ST: Guess
iw(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l53_c15
old_cw = cw(0,4);
cw(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l53_c15
// Check
ASSUME(active[iw(0,4)] == 0);
ASSUME(active[cw(0,4)] == 0);
ASSUME(sforbid(4,cw(0,4))== 0);
ASSUME(iw(0,4) >= 0);
ASSUME(iw(0,4) >= 0);
ASSUME(cw(0,4) >= iw(0,4));
ASSUME(cw(0,4) >= old_cw);
ASSUME(cw(0,4) >= cr(0,4));
ASSUME(cw(0,4) >= cl[0]);
ASSUME(cw(0,4) >= cisb[0]);
ASSUME(cw(0,4) >= cdy[0]);
ASSUME(cw(0,4) >= cdl[0]);
ASSUME(cw(0,4) >= cds[0]);
ASSUME(cw(0,4) >= cctrl[0]);
ASSUME(cw(0,4) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,4) = 0;
mem(4,cw(0,4)) = 0;
co(4,cw(0,4))+=1;
delta(4,cw(0,4)) = -1;
ASSUME(creturn[0] >= cw(0,4));
// %call = call i32 @pthread_create(i64* noundef %thr0, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t0, i8* noundef null) #7, !dbg !82
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[1] >= cdy[0]);
// %call3 = call i32 @pthread_create(i64* noundef %thr1, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t1, i8* noundef null) #7, !dbg !83
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[2] >= cdy[0]);
// %2 = load i64, i64* %thr0, align 8, !dbg !84, !tbaa !85
r7 = local_mem[0];
// %call4 = call i32 @pthread_join(i64 noundef %2, i8** noundef null), !dbg !87
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[1]);
// %3 = load i64, i64* %thr1, align 8, !dbg !88, !tbaa !85
r8 = local_mem[1];
// %call5 = call i32 @pthread_join(i64 noundef %3, i8** noundef null), !dbg !89
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[2]);
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !139, metadata !DIExpression()), !dbg !169
// %4 = load atomic i64, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !91
// LD: Guess
old_cr = cr(0,0);
cr(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l61_c13
// Check
ASSUME(active[cr(0,0)] == 0);
ASSUME(cr(0,0) >= iw(0,0));
ASSUME(cr(0,0) >= 0);
ASSUME(cr(0,0) >= cdy[0]);
ASSUME(cr(0,0) >= cisb[0]);
ASSUME(cr(0,0) >= cdl[0]);
ASSUME(cr(0,0) >= cl[0]);
// Update
creg_r9 = cr(0,0);
crmax(0,0) = max(crmax(0,0),cr(0,0));
caddr[0] = max(caddr[0],0);
if(cr(0,0) < cw(0,0)) {
r9 = buff(0,0);
ASSUME((!(( (cw(0,0) < 1) && (1 < crmax(0,0)) )))||(sforbid(0,1)> 0));
ASSUME((!(( (cw(0,0) < 2) && (2 < crmax(0,0)) )))||(sforbid(0,2)> 0));
ASSUME((!(( (cw(0,0) < 3) && (3 < crmax(0,0)) )))||(sforbid(0,3)> 0));
ASSUME((!(( (cw(0,0) < 4) && (4 < crmax(0,0)) )))||(sforbid(0,4)> 0));
} else {
if(pw(0,0) != co(0,cr(0,0))) {
ASSUME(cr(0,0) >= old_cr);
}
pw(0,0) = co(0,cr(0,0));
r9 = mem(0,cr(0,0));
}
ASSUME(creturn[0] >= cr(0,0));
// call void @llvm.dbg.value(metadata i64 %4, metadata !141, metadata !DIExpression()), !dbg !169
// %conv = trunc i64 %4 to i32, !dbg !92
// call void @llvm.dbg.value(metadata i32 %conv, metadata !138, metadata !DIExpression()), !dbg !149
// %cmp = icmp eq i32 %conv, 4, !dbg !93
creg__r9__4_ = max(0,creg_r9);
// %conv6 = zext i1 %cmp to i32, !dbg !93
// call void @llvm.dbg.value(metadata i32 %conv6, metadata !142, metadata !DIExpression()), !dbg !149
// %5 = load i32, i32* @atom_0_X6_3, align 4, !dbg !94, !tbaa !76
// LD: Guess
old_cr = cr(0,2);
cr(0,2) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l63_c13
// Check
ASSUME(active[cr(0,2)] == 0);
ASSUME(cr(0,2) >= iw(0,2));
ASSUME(cr(0,2) >= 0);
ASSUME(cr(0,2) >= cdy[0]);
ASSUME(cr(0,2) >= cisb[0]);
ASSUME(cr(0,2) >= cdl[0]);
ASSUME(cr(0,2) >= cl[0]);
// Update
creg_r10 = cr(0,2);
crmax(0,2) = max(crmax(0,2),cr(0,2));
caddr[0] = max(caddr[0],0);
if(cr(0,2) < cw(0,2)) {
r10 = buff(0,2);
ASSUME((!(( (cw(0,2) < 1) && (1 < crmax(0,2)) )))||(sforbid(2,1)> 0));
ASSUME((!(( (cw(0,2) < 2) && (2 < crmax(0,2)) )))||(sforbid(2,2)> 0));
ASSUME((!(( (cw(0,2) < 3) && (3 < crmax(0,2)) )))||(sforbid(2,3)> 0));
ASSUME((!(( (cw(0,2) < 4) && (4 < crmax(0,2)) )))||(sforbid(2,4)> 0));
} else {
if(pw(0,2) != co(2,cr(0,2))) {
ASSUME(cr(0,2) >= old_cr);
}
pw(0,2) = co(2,cr(0,2));
r10 = mem(2,cr(0,2));
}
ASSUME(creturn[0] >= cr(0,2));
// call void @llvm.dbg.value(metadata i32 %5, metadata !143, metadata !DIExpression()), !dbg !149
// %6 = load i32, i32* @atom_1_X3_4, align 4, !dbg !95, !tbaa !76
// LD: Guess
old_cr = cr(0,3);
cr(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l64_c13
// Check
ASSUME(active[cr(0,3)] == 0);
ASSUME(cr(0,3) >= iw(0,3));
ASSUME(cr(0,3) >= 0);
ASSUME(cr(0,3) >= cdy[0]);
ASSUME(cr(0,3) >= cisb[0]);
ASSUME(cr(0,3) >= cdl[0]);
ASSUME(cr(0,3) >= cl[0]);
// Update
creg_r11 = cr(0,3);
crmax(0,3) = max(crmax(0,3),cr(0,3));
caddr[0] = max(caddr[0],0);
if(cr(0,3) < cw(0,3)) {
r11 = buff(0,3);
ASSUME((!(( (cw(0,3) < 1) && (1 < crmax(0,3)) )))||(sforbid(3,1)> 0));
ASSUME((!(( (cw(0,3) < 2) && (2 < crmax(0,3)) )))||(sforbid(3,2)> 0));
ASSUME((!(( (cw(0,3) < 3) && (3 < crmax(0,3)) )))||(sforbid(3,3)> 0));
ASSUME((!(( (cw(0,3) < 4) && (4 < crmax(0,3)) )))||(sforbid(3,4)> 0));
} else {
if(pw(0,3) != co(3,cr(0,3))) {
ASSUME(cr(0,3) >= old_cr);
}
pw(0,3) = co(3,cr(0,3));
r11 = mem(3,cr(0,3));
}
ASSUME(creturn[0] >= cr(0,3));
// call void @llvm.dbg.value(metadata i32 %6, metadata !144, metadata !DIExpression()), !dbg !149
// %7 = load i32, i32* @atom_1_X2_3, align 4, !dbg !96, !tbaa !76
// LD: Guess
old_cr = cr(0,4);
cr(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l65_c13
// Check
ASSUME(active[cr(0,4)] == 0);
ASSUME(cr(0,4) >= iw(0,4));
ASSUME(cr(0,4) >= 0);
ASSUME(cr(0,4) >= cdy[0]);
ASSUME(cr(0,4) >= cisb[0]);
ASSUME(cr(0,4) >= cdl[0]);
ASSUME(cr(0,4) >= cl[0]);
// Update
creg_r12 = cr(0,4);
crmax(0,4) = max(crmax(0,4),cr(0,4));
caddr[0] = max(caddr[0],0);
if(cr(0,4) < cw(0,4)) {
r12 = buff(0,4);
ASSUME((!(( (cw(0,4) < 1) && (1 < crmax(0,4)) )))||(sforbid(4,1)> 0));
ASSUME((!(( (cw(0,4) < 2) && (2 < crmax(0,4)) )))||(sforbid(4,2)> 0));
ASSUME((!(( (cw(0,4) < 3) && (3 < crmax(0,4)) )))||(sforbid(4,3)> 0));
ASSUME((!(( (cw(0,4) < 4) && (4 < crmax(0,4)) )))||(sforbid(4,4)> 0));
} else {
if(pw(0,4) != co(4,cr(0,4))) {
ASSUME(cr(0,4) >= old_cr);
}
pw(0,4) = co(4,cr(0,4));
r12 = mem(4,cr(0,4));
}
ASSUME(creturn[0] >= cr(0,4));
// call void @llvm.dbg.value(metadata i32 %7, metadata !145, metadata !DIExpression()), !dbg !149
// %and = and i32 %6, %7, !dbg !97
creg_r13 = max(creg_r11,creg_r12);
r13 = r11 & r12;
// call void @llvm.dbg.value(metadata i32 %and, metadata !146, metadata !DIExpression()), !dbg !149
// %and7 = and i32 %5, %and, !dbg !98
creg_r14 = max(creg_r10,creg_r13);
r14 = r10 & r13;
// call void @llvm.dbg.value(metadata i32 %and7, metadata !147, metadata !DIExpression()), !dbg !149
// %and8 = and i32 %conv6, %and7, !dbg !99
creg_r15 = max(creg__r9__4_,creg_r14);
r15 = (r9==4) & r14;
// call void @llvm.dbg.value(metadata i32 %and8, metadata !148, metadata !DIExpression()), !dbg !149
// %cmp9 = icmp eq i32 %and8, 1, !dbg !100
creg__r15__1_ = max(0,creg_r15);
// br i1 %cmp9, label %if.then, label %if.end, !dbg !102
old_cctrl = cctrl[0];
cctrl[0] = get_rng(0,NCONTEXT-1);
ASSUME(cctrl[0] >= old_cctrl);
ASSUME(cctrl[0] >= creg__r15__1_);
if((r15==1)) {
goto T0BLOCK1;
} else {
goto T0BLOCK2;
}
T0BLOCK1:
// call void @__assert_fail(i8* noundef getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8* noundef getelementptr inbounds ([106 x i8], [106 x i8]* @.str.1, i64 0, i64 0), i32 noundef 69, i8* noundef getelementptr inbounds ([23 x i8], [23 x i8]* @__PRETTY_FUNCTION__.main, i64 0, i64 0)) #8, !dbg !103
// unreachable, !dbg !103
r16 = 1;
goto T0BLOCK_END;
T0BLOCK2:
// %8 = bitcast i64* %thr1 to i8*, !dbg !106
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %8) #7, !dbg !106
// %9 = bitcast i64* %thr0 to i8*, !dbg !106
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %9) #7, !dbg !106
// ret i32 0, !dbg !107
ret_thread_0 = 0;
goto T0BLOCK_END;
T0BLOCK_END:
ASSUME(meminit(0,1) == mem(0,0));
ASSUME(coinit(0,1) == co(0,0));
ASSUME(deltainit(0,1) == delta(0,0));
ASSUME(meminit(0,2) == mem(0,1));
ASSUME(coinit(0,2) == co(0,1));
ASSUME(deltainit(0,2) == delta(0,1));
ASSUME(meminit(0,3) == mem(0,2));
ASSUME(coinit(0,3) == co(0,2));
ASSUME(deltainit(0,3) == delta(0,2));
ASSUME(meminit(0,4) == mem(0,3));
ASSUME(coinit(0,4) == co(0,3));
ASSUME(deltainit(0,4) == delta(0,3));
ASSUME(meminit(1,1) == mem(1,0));
ASSUME(coinit(1,1) == co(1,0));
ASSUME(deltainit(1,1) == delta(1,0));
ASSUME(meminit(1,2) == mem(1,1));
ASSUME(coinit(1,2) == co(1,1));
ASSUME(deltainit(1,2) == delta(1,1));
ASSUME(meminit(1,3) == mem(1,2));
ASSUME(coinit(1,3) == co(1,2));
ASSUME(deltainit(1,3) == delta(1,2));
ASSUME(meminit(1,4) == mem(1,3));
ASSUME(coinit(1,4) == co(1,3));
ASSUME(deltainit(1,4) == delta(1,3));
ASSUME(meminit(2,1) == mem(2,0));
ASSUME(coinit(2,1) == co(2,0));
ASSUME(deltainit(2,1) == delta(2,0));
ASSUME(meminit(2,2) == mem(2,1));
ASSUME(coinit(2,2) == co(2,1));
ASSUME(deltainit(2,2) == delta(2,1));
ASSUME(meminit(2,3) == mem(2,2));
ASSUME(coinit(2,3) == co(2,2));
ASSUME(deltainit(2,3) == delta(2,2));
ASSUME(meminit(2,4) == mem(2,3));
ASSUME(coinit(2,4) == co(2,3));
ASSUME(deltainit(2,4) == delta(2,3));
ASSUME(meminit(3,1) == mem(3,0));
ASSUME(coinit(3,1) == co(3,0));
ASSUME(deltainit(3,1) == delta(3,0));
ASSUME(meminit(3,2) == mem(3,1));
ASSUME(coinit(3,2) == co(3,1));
ASSUME(deltainit(3,2) == delta(3,1));
ASSUME(meminit(3,3) == mem(3,2));
ASSUME(coinit(3,3) == co(3,2));
ASSUME(deltainit(3,3) == delta(3,2));
ASSUME(meminit(3,4) == mem(3,3));
ASSUME(coinit(3,4) == co(3,3));
ASSUME(deltainit(3,4) == delta(3,3));
ASSUME(meminit(4,1) == mem(4,0));
ASSUME(coinit(4,1) == co(4,0));
ASSUME(deltainit(4,1) == delta(4,0));
ASSUME(meminit(4,2) == mem(4,1));
ASSUME(coinit(4,2) == co(4,1));
ASSUME(deltainit(4,2) == delta(4,1));
ASSUME(meminit(4,3) == mem(4,2));
ASSUME(coinit(4,3) == co(4,2));
ASSUME(deltainit(4,3) == delta(4,2));
ASSUME(meminit(4,4) == mem(4,3));
ASSUME(coinit(4,4) == co(4,3));
ASSUME(deltainit(4,4) == delta(4,3));
ASSERT(r16== 0);
}
| [
"tuan-phong.ngo@it.uu.se"
] | tuan-phong.ngo@it.uu.se |
c0a1d832ca5473d06891312e55d64dc83e415509 | 0d2aa5db8586678c5a37287e3574f7796bf8ff3a | /src/plugins/poshuku/interfaces/poshuku/iflashoverrider.h | df2919c45595a5b2d3fad59bbc8ace848c212474 | [
"BSL-1.0"
] | permissive | rayslava/leechcraft | 129a4e0a9dc9730ed7db0f30248bb9ce0b77b920 | 4ecc8aa56dc6030d2593922ff41b00ff50902db8 | refs/heads/master | 2021-01-17T23:58:23.139308 | 2016-03-03T14:37:21 | 2016-03-03T14:37:21 | 2,128,687 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,106 | h | /**********************************************************************
* LeechCraft - modular cross-platform feature rich internet client.
* Copyright (C) 2006-2014 Georg Rudoy
*
* Boost Software License - Version 1.0 - August 17th, 2003
*
* Permission is hereby granted, free of charge, to any person or organization
* obtaining a copy of the software and accompanying documentation covered by
* this license (the "Software") to use, reproduce, display, distribute,
* execute, and transmit the Software, and to prepare derivative works of the
* Software, and to permit third-parties to whom the Software is furnished to
* do so, all subject to the following:
*
* The copyright notices in the Software and this entire statement, including
* the above license grant, this restriction and the following disclaimer,
* must be included in all copies of the Software, in whole or in part, and
* all derivative works of the Software, unless such copies or derivative
* works are solely in the form of machine-executable object code generated by
* a source language processor.
*
* 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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
* SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
* FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
**********************************************************************/
#ifndef PLUGINS_POSHUKU_INTERFACES_IFLASHOVERRIDER_H
#define PLUGINS_POSHUKU_INTERFACES_IFLASHOVERRIDER_H
#include <QtPlugin>
class QUrl;
namespace LeechCraft
{
namespace Poshuku
{
class IFlashOverrider
{
public:
virtual ~IFlashOverrider () {}
virtual bool WouldOverrideFlash (const QUrl&) const = 0;
};
}
}
Q_DECLARE_INTERFACE (LeechCraft::Poshuku::IFlashOverrider,
"org.Deviant.LeechCraft.Poshuku.IFlashOverrider/1.0");
#endif
| [
"0xd34df00d@gmail.com"
] | 0xd34df00d@gmail.com |
541a3580da9b6612c914679291932248997cde49 | bc39b43f556c8bf78872662522af2ee311637b43 | /services/tracing/public/cpp/base_agent.h | f93c8dc44fd9ef05c17012f63c9144b7d02fe944 | [
"BSD-3-Clause"
] | permissive | shahzadlone/chromium | a0b3cb45909a6232e4f94557d7c41668b4ae9a21 | cd1c297873cd93013b043744950ad0ac121ad351 | refs/heads/master | 2023-01-01T13:40:42.049827 | 2019-01-21T00:01:26 | 2019-01-21T00:01:26 | 166,625,000 | 0 | 0 | NOASSERTION | 2019-01-20T05:01:40 | 2019-01-20T05:01:40 | null | UTF-8 | C++ | false | false | 1,775 | h | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef SERVICES_TRACING_PUBLIC_CPP_BASE_AGENT_H_
#define SERVICES_TRACING_PUBLIC_CPP_BASE_AGENT_H_
#include <string>
#include "base/component_export.h"
#include "mojo/public/cpp/bindings/binding.h"
#include "services/tracing/public/mojom/tracing.mojom.h"
namespace service_manager {
class Connector;
} // namespace service_manager
// This class is a minimal implementation of mojom::Agent to reduce boilerplate
// code in tracing agents. A tracing agent can inherit from this class and only
// override methods that actually do something, in most cases only StartTracing
// and StopAndFlush.
namespace tracing {
class COMPONENT_EXPORT(TRACING_CPP) BaseAgent : public mojom::Agent {
public:
~BaseAgent() override;
virtual void Connect(service_manager::Connector* connector);
virtual void GetCategories(std::set<std::string>* category_set);
protected:
BaseAgent(const std::string& label,
mojom::TraceDataType type,
base::ProcessId pid);
private:
// tracing::mojom::Agent:
void StartTracing(const std::string& config,
base::TimeTicks coordinator_time,
Agent::StartTracingCallback callback) override;
void StopAndFlush(tracing::mojom::RecorderPtr recorder) override;
void RequestBufferStatus(
Agent::RequestBufferStatusCallback callback) override;
mojo::Binding<tracing::mojom::Agent> binding_;
const std::string label_;
const mojom::TraceDataType type_;
const base::ProcessId pid_;
DISALLOW_COPY_AND_ASSIGN(BaseAgent);
};
} // namespace tracing
#endif // SERVICES_TRACING_PUBLIC_CPP_BASE_AGENT_H_
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
7c61e467a5efdc8890308c3ef2a1ba4bd9ecfac0 | 5efa11188f7750b3a8caa995341614fc2827ed4d | /chrome/browser/nearby_sharing/nearby_connections_manager_impl.cc | 05914c38f942195e079ba79416990ea0a813d0eb | [
"BSD-3-Clause"
] | permissive | gpsbird/chromium | 2b3431360d172f7ca939b50cfdb0590cbc6f0b7c | 57737aa8a747742505d520b855dd4a85af5c746b | refs/heads/master | 2022-12-31T17:23:06.895837 | 2020-11-23T08:40:07 | 2020-11-23T08:40:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 22,227 | cc | // Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/nearby_sharing/nearby_connections_manager_impl.h"
#include "base/files/file_util.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/post_task.h"
#include "base/unguessable_token.h"
#include "chrome/browser/nearby_sharing/common/nearby_share_features.h"
#include "chrome/browser/nearby_sharing/constants.h"
#include "chrome/browser/nearby_sharing/logging/logging.h"
#include "chromeos/services/nearby/public/mojom/nearby_connections_types.mojom.h"
#include "crypto/random.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "net/base/network_change_notifier.h"
namespace {
const char kServiceId[] = "NearbySharing";
const char kFastAdvertisementServiceUuid[] =
"0000fef3-0000-1000-8000-00805f9b34fb";
const location::nearby::connections::mojom::Strategy kStrategy =
location::nearby::connections::mojom::Strategy::kP2pPointToPoint;
bool ShouldEnableWebRtc(DataUsage data_usage, PowerLevel power_level) {
if (!base::FeatureList::IsEnabled(features::kNearbySharingWebRtc))
return false;
// We won't use internet if the user requested we don't.
if (data_usage == DataUsage::kOffline)
return false;
// We won't use internet in a low power mode.
if (power_level == PowerLevel::kLowPower)
return false;
net::NetworkChangeNotifier::ConnectionType connection_type =
net::NetworkChangeNotifier::GetConnectionType();
// Verify that this network has an internet connection.
if (connection_type == net::NetworkChangeNotifier::CONNECTION_NONE)
return false;
// If the user wants to limit WebRTC, then only use it on unmetered networks.
if (data_usage == DataUsage::kWifiOnly)
return !net::NetworkChangeNotifier::IsConnectionCellular(connection_type);
// We're online, the user hasn't disabled WebRTC, let's use it!
return true;
}
} // namespace
NearbyConnectionsManagerImpl::NearbyConnectionsManagerImpl(
NearbyProcessManager* process_manager,
Profile* profile)
: process_manager_(process_manager), profile_(profile) {
DCHECK(process_manager_);
DCHECK(profile_);
nearby_process_observer_.Add(process_manager_);
}
NearbyConnectionsManagerImpl::~NearbyConnectionsManagerImpl() {
ClearIncomingPayloads();
}
void NearbyConnectionsManagerImpl::Shutdown() {
Reset();
}
void NearbyConnectionsManagerImpl::StartAdvertising(
std::vector<uint8_t> endpoint_info,
IncomingConnectionListener* listener,
PowerLevel power_level,
DataUsage data_usage,
ConnectionsCallback callback) {
DCHECK(listener);
DCHECK(!incoming_connection_listener_);
if (!BindNearbyConnections()) {
NS_LOG(ERROR) << __func__ << ": BindNearbyConnections() failed.";
std::move(callback).Run(ConnectionsStatus::kError);
return;
}
bool is_high_power = power_level == PowerLevel::kHighPower;
bool use_ble = !is_high_power;
auto allowed_mediums = MediumSelection::New(
/*bluetooth=*/is_high_power, /*ble=*/use_ble,
ShouldEnableWebRtc(data_usage, power_level),
/*wifi_lan=*/is_high_power && kIsWifiLanSupported);
mojo::PendingRemote<ConnectionLifecycleListener> lifecycle_listener;
connection_lifecycle_listeners_.Add(
this, lifecycle_listener.InitWithNewPipeAndPassReceiver());
incoming_connection_listener_ = listener;
nearby_connections_->StartAdvertising(
kServiceId, endpoint_info,
AdvertisingOptions::New(
kStrategy, std::move(allowed_mediums),
/*auto_upgrade_bandwidth=*/is_high_power,
/*enforce_topology_constraints=*/true,
/*enable_bluetooth_listening=*/use_ble,
/*fast_advertisement_service_uuid=*/
device::BluetoothUUID(kFastAdvertisementServiceUuid)),
std::move(lifecycle_listener), std::move(callback));
}
void NearbyConnectionsManagerImpl::StopAdvertising() {
if (nearby_connections_) {
nearby_connections_->StopAdvertising(
kServiceId, base::BindOnce([](ConnectionsStatus status) {
NS_LOG(VERBOSE) << __func__
<< ": Stop advertising attempted over Nearby "
"Connections with result: "
<< ConnectionsStatusToString(status);
}));
}
incoming_connection_listener_ = nullptr;
}
void NearbyConnectionsManagerImpl::StartDiscovery(
DiscoveryListener* listener,
DataUsage data_usage,
ConnectionsCallback callback) {
DCHECK(listener);
DCHECK(!discovery_listener_);
if (!BindNearbyConnections()) {
NS_LOG(ERROR) << __func__ << ": BindNearbyConnections() failed.";
std::move(callback).Run(ConnectionsStatus::kError);
return;
}
auto allowed_mediums = MediumSelection::New(
/*bluetooth=*/true,
/*ble=*/true,
/*webrtc=*/ShouldEnableWebRtc(data_usage, PowerLevel::kHighPower),
/*wifi_lan=*/kIsWifiLanSupported);
discovery_listener_ = listener;
nearby_connections_->StartDiscovery(
kServiceId,
DiscoveryOptions::New(
kStrategy, std::move(allowed_mediums),
device::BluetoothUUID(kFastAdvertisementServiceUuid),
/*is_out_of_band_connection=*/false),
endpoint_discovery_listener_.BindNewPipeAndPassRemote(),
std::move(callback));
}
void NearbyConnectionsManagerImpl::StopDiscovery() {
if (nearby_connections_) {
nearby_connections_->StopDiscovery(
kServiceId, base::BindOnce([](ConnectionsStatus status) {
NS_LOG(VERBOSE) << __func__
<< ": Stop discovery attempted over Nearby "
"Connections with result: "
<< ConnectionsStatusToString(status);
}));
}
discovered_endpoints_.clear();
discovery_listener_ = nullptr;
endpoint_discovery_listener_.reset();
}
void NearbyConnectionsManagerImpl::Connect(
std::vector<uint8_t> endpoint_info,
const std::string& endpoint_id,
base::Optional<std::vector<uint8_t>> bluetooth_mac_address,
DataUsage data_usage,
NearbyConnectionCallback callback) {
if (!nearby_connections_) {
std::move(callback).Run(nullptr);
return;
}
if (bluetooth_mac_address && bluetooth_mac_address->size() != 6)
bluetooth_mac_address.reset();
auto allowed_mediums = MediumSelection::New(
/*bluetooth=*/true,
/*ble=*/false, ShouldEnableWebRtc(data_usage, PowerLevel::kHighPower),
/*wifi_lan=*/kIsWifiLanSupported);
mojo::PendingRemote<ConnectionLifecycleListener> lifecycle_listener;
connection_lifecycle_listeners_.Add(
this, lifecycle_listener.InitWithNewPipeAndPassReceiver());
auto result =
pending_outgoing_connections_.emplace(endpoint_id, std::move(callback));
DCHECK(result.second);
auto timeout_timer = std::make_unique<base::OneShotTimer>();
timeout_timer->Start(
FROM_HERE, kInitiateNearbyConnectionTimeout,
base::BindOnce(&NearbyConnectionsManagerImpl::OnConnectionTimedOut,
weak_ptr_factory_.GetWeakPtr(), endpoint_id));
connect_timeout_timers_.emplace(endpoint_id, std::move(timeout_timer));
nearby_connections_->RequestConnection(
kServiceId, endpoint_info, endpoint_id,
ConnectionOptions::New(std::move(allowed_mediums),
std::move(bluetooth_mac_address)),
std::move(lifecycle_listener),
base::BindOnce(&NearbyConnectionsManagerImpl::OnConnectionRequested,
weak_ptr_factory_.GetWeakPtr(), endpoint_id));
}
void NearbyConnectionsManagerImpl::OnConnectionTimedOut(
const std::string& endpoint_id) {
NS_LOG(ERROR) << "Failed to connect to the remote shareTarget: Timed out.";
Disconnect(endpoint_id);
}
void NearbyConnectionsManagerImpl::OnConnectionRequested(
const std::string& endpoint_id,
ConnectionsStatus status) {
auto it = pending_outgoing_connections_.find(endpoint_id);
if (it == pending_outgoing_connections_.end())
return;
if (status != ConnectionsStatus::kSuccess) {
NS_LOG(ERROR) << "Failed to connect to the remote shareTarget: "
<< ConnectionsStatusToString(status);
Disconnect(endpoint_id);
return;
}
// TODO(crbug/1111458): Support TransferManager.
}
void NearbyConnectionsManagerImpl::Disconnect(const std::string& endpoint_id) {
if (!nearby_connections_)
return;
nearby_connections_->DisconnectFromEndpoint(
kServiceId, endpoint_id,
base::BindOnce(
[](const std::string& endpoint_id, ConnectionsStatus status) {
NS_LOG(VERBOSE)
<< __func__ << ": Disconnecting from endpoint " << endpoint_id
<< " attempted over Nearby Connections with result: "
<< ConnectionsStatusToString(status);
},
endpoint_id));
OnDisconnected(endpoint_id);
NS_LOG(INFO) << "Disconnected from " << endpoint_id;
}
void NearbyConnectionsManagerImpl::Send(const std::string& endpoint_id,
PayloadPtr payload,
PayloadStatusListener* listener) {
if (!nearby_connections_)
return;
if (listener)
RegisterPayloadStatusListener(payload->id, listener);
nearby_connections_->SendPayload(
kServiceId, {endpoint_id}, std::move(payload),
base::BindOnce(
[](const std::string& endpoint_id, ConnectionsStatus status) {
NS_LOG(VERBOSE)
<< __func__ << ": Sending payload to endpoint " << endpoint_id
<< " attempted over Nearby Connections with result: "
<< ConnectionsStatusToString(status);
},
endpoint_id));
}
void NearbyConnectionsManagerImpl::RegisterPayloadStatusListener(
int64_t payload_id,
PayloadStatusListener* listener) {
payload_status_listeners_.insert_or_assign(payload_id, listener);
}
void NearbyConnectionsManagerImpl::RegisterPayloadPath(
int64_t payload_id,
const base::FilePath& file_path,
ConnectionsCallback callback) {
if (!nearby_connections_)
return;
DCHECK(!file_path.empty());
file_handler_.CreateFile(
file_path, base::BindOnce(&NearbyConnectionsManagerImpl::OnFileCreated,
weak_ptr_factory_.GetWeakPtr(), payload_id,
std::move(callback)));
}
void NearbyConnectionsManagerImpl::OnFileCreated(
int64_t payload_id,
ConnectionsCallback callback,
NearbyFileHandler::CreateFileResult result) {
nearby_connections_->RegisterPayloadFile(
kServiceId, payload_id, std::move(result.input_file),
std::move(result.output_file), std::move(callback));
}
NearbyConnectionsManagerImpl::Payload*
NearbyConnectionsManagerImpl::GetIncomingPayload(int64_t payload_id) {
auto it = incoming_payloads_.find(payload_id);
if (it == incoming_payloads_.end())
return nullptr;
return it->second.get();
}
void NearbyConnectionsManagerImpl::Cancel(int64_t payload_id) {
if (!nearby_connections_)
return;
auto it = payload_status_listeners_.find(payload_id);
if (it != payload_status_listeners_.end()) {
it->second->OnStatusUpdate(
PayloadTransferUpdate::New(payload_id, PayloadStatus::kCanceled,
/*total_bytes=*/0,
/*bytes_transferred=*/0));
payload_status_listeners_.erase(it);
}
nearby_connections_->CancelPayload(
kServiceId, payload_id,
base::BindOnce(
[](int64_t payload_id, ConnectionsStatus status) {
NS_LOG(VERBOSE)
<< __func__ << ": Cancelling payload to id " << payload_id
<< " attempted over Nearby Connections with result: "
<< ConnectionsStatusToString(status);
},
payload_id));
NS_LOG(INFO) << "Cancelling payload: " << payload_id;
}
void NearbyConnectionsManagerImpl::ClearIncomingPayloads() {
std::vector<PayloadPtr> payloads;
for (auto& it : incoming_payloads_) {
payloads.push_back(std::move(it.second));
// Make sure to clean up the raw pointer to the payload listener.
auto listener_it = payload_status_listeners_.find(it.first);
if (listener_it != payload_status_listeners_.end()) {
payload_status_listeners_.erase(listener_it);
}
}
file_handler_.ReleaseFilePayloads(std::move(payloads));
incoming_payloads_.clear();
}
base::Optional<std::vector<uint8_t>>
NearbyConnectionsManagerImpl::GetRawAuthenticationToken(
const std::string& endpoint_id) {
auto it = connection_info_map_.find(endpoint_id);
if (it == connection_info_map_.end())
return base::nullopt;
return it->second->raw_authentication_token;
}
void NearbyConnectionsManagerImpl::UpgradeBandwidth(
const std::string& endpoint_id) {
if (!nearby_connections_)
return;
// The only bandwidth upgrade at this point is WebRTC.
if (!base::FeatureList::IsEnabled(features::kNearbySharingWebRtc))
return;
nearby_connections_->InitiateBandwidthUpgrade(
kServiceId, endpoint_id,
base::BindOnce(
[](const std::string& endpoint_id, ConnectionsStatus status) {
NS_LOG(VERBOSE)
<< __func__ << ": Bandwidth upgrade attempted to endpoint "
<< endpoint_id << "over Nearby Connections with result: "
<< ConnectionsStatusToString(status);
base::UmaHistogramBoolean(
"Nearby.Share.Medium.InitiateBandwidthUpgradeResult",
status == ConnectionsStatus::kSuccess);
},
endpoint_id));
}
void NearbyConnectionsManagerImpl::OnNearbyProfileChanged(Profile* profile) {
NS_LOG(VERBOSE) << __func__;
}
void NearbyConnectionsManagerImpl::OnNearbyProcessStarted() {
NS_LOG(VERBOSE) << __func__;
}
void NearbyConnectionsManagerImpl::OnNearbyProcessStopped() {
NS_LOG(VERBOSE) << __func__;
// Not safe to use nearby_connections after we are notified the process has
// been stopped.
nearby_connections_ = nullptr;
Reset();
}
void NearbyConnectionsManagerImpl::OnEndpointFound(
const std::string& endpoint_id,
DiscoveredEndpointInfoPtr info) {
if (!discovery_listener_) {
NS_LOG(INFO) << "Ignoring discovered endpoint "
<< base::HexEncode(info->endpoint_info.data(),
info->endpoint_info.size())
<< " because we're no longer "
"in discovery mode";
return;
}
auto result = discovered_endpoints_.insert(endpoint_id);
if (!result.second) {
NS_LOG(INFO) << "Ignoring discovered endpoint "
<< base::HexEncode(info->endpoint_info.data(),
info->endpoint_info.size())
<< " because we've already "
"reported this endpoint";
return;
}
discovery_listener_->OnEndpointDiscovered(endpoint_id, info->endpoint_info);
NS_LOG(INFO) << "Discovered "
<< base::HexEncode(info->endpoint_info.data(),
info->endpoint_info.size())
<< " over Nearby Connections";
}
void NearbyConnectionsManagerImpl::OnEndpointLost(
const std::string& endpoint_id) {
if (!discovered_endpoints_.erase(endpoint_id)) {
NS_LOG(INFO) << "Ignoring lost endpoint " << endpoint_id
<< " because we haven't reported this endpoint";
return;
}
if (!discovery_listener_) {
NS_LOG(INFO) << "Ignoring lost endpoint " << endpoint_id
<< " because we're no longer in discovery mode";
return;
}
discovery_listener_->OnEndpointLost(endpoint_id);
NS_LOG(INFO) << "Endpoint " << endpoint_id << " lost over Nearby Connections";
}
void NearbyConnectionsManagerImpl::OnConnectionInitiated(
const std::string& endpoint_id,
ConnectionInfoPtr info) {
auto result = connection_info_map_.emplace(endpoint_id, std::move(info));
DCHECK(result.second);
mojo::PendingRemote<PayloadListener> payload_listener;
payload_listeners_.Add(this,
payload_listener.InitWithNewPipeAndPassReceiver());
nearby_connections_->AcceptConnection(
kServiceId, endpoint_id, std::move(payload_listener),
base::BindOnce(
[](const std::string& endpoint_id, ConnectionsStatus status) {
NS_LOG(VERBOSE)
<< __func__ << ": Accept connection attempted to endpoint "
<< endpoint_id << " over Nearby Connections with result: "
<< ConnectionsStatusToString(status);
},
endpoint_id));
}
void NearbyConnectionsManagerImpl::OnConnectionAccepted(
const std::string& endpoint_id) {
auto it = connection_info_map_.find(endpoint_id);
if (it == connection_info_map_.end())
return;
if (it->second->is_incoming_connection) {
if (!incoming_connection_listener_) {
// Not in advertising mode.
Disconnect(endpoint_id);
return;
}
auto result = connections_.emplace(
endpoint_id, std::make_unique<NearbyConnectionImpl>(this, endpoint_id));
DCHECK(result.second);
incoming_connection_listener_->OnIncomingConnection(
endpoint_id, it->second->endpoint_info, result.first->second.get());
} else {
auto it = pending_outgoing_connections_.find(endpoint_id);
if (it == pending_outgoing_connections_.end()) {
Disconnect(endpoint_id);
return;
}
auto result = connections_.emplace(
endpoint_id, std::make_unique<NearbyConnectionImpl>(this, endpoint_id));
DCHECK(result.second);
std::move(it->second).Run(result.first->second.get());
pending_outgoing_connections_.erase(it);
connect_timeout_timers_.erase(endpoint_id);
}
}
void NearbyConnectionsManagerImpl::OnConnectionRejected(
const std::string& endpoint_id,
Status status) {
connection_info_map_.erase(endpoint_id);
auto it = pending_outgoing_connections_.find(endpoint_id);
if (it != pending_outgoing_connections_.end()) {
std::move(it->second).Run(nullptr);
pending_outgoing_connections_.erase(it);
connect_timeout_timers_.erase(endpoint_id);
}
// TODO(crbug/1111458): Support TransferManager.
}
void NearbyConnectionsManagerImpl::OnDisconnected(
const std::string& endpoint_id) {
connection_info_map_.erase(endpoint_id);
auto it = pending_outgoing_connections_.find(endpoint_id);
if (it != pending_outgoing_connections_.end()) {
std::move(it->second).Run(nullptr);
pending_outgoing_connections_.erase(it);
connect_timeout_timers_.erase(endpoint_id);
}
connections_.erase(endpoint_id);
// TODO(crbug/1111458): Support TransferManager.
}
void NearbyConnectionsManagerImpl::OnBandwidthChanged(
const std::string& endpoint_id,
Medium medium) {
NS_LOG(VERBOSE) << __func__ << ": Changed to medium " << medium;
base::UmaHistogramEnumeration("Nearby.Share.Medium.ChangedToMedium", medium);
// TODO(crbug/1111458): Support TransferManager.
}
void NearbyConnectionsManagerImpl::OnPayloadReceived(
const std::string& endpoint_id,
PayloadPtr payload) {
auto result = incoming_payloads_.emplace(payload->id, std::move(payload));
DCHECK(result.second);
}
void NearbyConnectionsManagerImpl::OnPayloadTransferUpdate(
const std::string& endpoint_id,
PayloadTransferUpdatePtr update) {
// If this is a payload we've registered for, then forward its status to the
// PayloadStatusListener. We don't need to do anything more with the payload.
auto listener_it = payload_status_listeners_.find(update->payload_id);
if (listener_it != payload_status_listeners_.end()) {
PayloadStatusListener* listener = listener_it->second;
switch (update->status) {
case PayloadStatus::kInProgress:
break;
case PayloadStatus::kSuccess:
case PayloadStatus::kCanceled:
case PayloadStatus::kFailure:
payload_status_listeners_.erase(listener_it);
break;
}
listener->OnStatusUpdate(std::move(update));
return;
}
// If this is an incoming payload that we have not registered for, then we'll
// treat it as a control frame (eg. IntroductionFrame) and forward it to the
// associated NearbyConnection.
auto payload_it = incoming_payloads_.find(update->payload_id);
if (payload_it == incoming_payloads_.end())
return;
if (!payload_it->second->content->is_bytes()) {
NS_LOG(WARNING) << "Received unknown payload of file type. Cancelling.";
nearby_connections_->CancelPayload(kServiceId, payload_it->first,
base::DoNothing());
return;
}
if (update->status != PayloadStatus::kSuccess)
return;
auto connections_it = connections_.find(endpoint_id);
if (connections_it == connections_.end())
return;
NS_LOG(INFO) << "Writing incoming byte message to NearbyConnection.";
connections_it->second->WriteMessage(
payload_it->second->content->get_bytes()->bytes);
}
bool NearbyConnectionsManagerImpl::BindNearbyConnections() {
if (!nearby_connections_) {
nearby_connections_ =
process_manager_->GetOrStartNearbyConnections(profile_);
}
return nearby_connections_ != nullptr;
}
void NearbyConnectionsManagerImpl::Reset() {
if (nearby_connections_) {
nearby_connections_->StopAllEndpoints(
kServiceId, base::BindOnce([](ConnectionsStatus status) {
NS_LOG(VERBOSE) << __func__
<< ": Stop all endpoints attempted over Nearby "
"Connections with result: "
<< ConnectionsStatusToString(status);
}));
}
nearby_connections_ = nullptr;
discovered_endpoints_.clear();
payload_status_listeners_.clear();
ClearIncomingPayloads();
connections_.clear();
connection_info_map_.clear();
discovery_listener_ = nullptr;
incoming_connection_listener_ = nullptr;
endpoint_discovery_listener_.reset();
connect_timeout_timers_.clear();
for (auto& entry : pending_outgoing_connections_)
std::move(entry.second).Run(/*connection=*/nullptr);
pending_outgoing_connections_.clear();
}
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
4b7c3b0e2ba99d86415d578d3430603ef0880695 | 65d0f1c583c3d571248566f5f124af74e8a76153 | /gxcom/ByteConverter.h | f81072a4402d20a42386d3f1be94af3207f22f99 | [] | no_license | chenfarong/mmorpg-server | 2d67fa014213cbef91ae51face3266caaabb3c39 | e8a649d12dc10c54f9ada8f5588b1ce2dd80e15e | refs/heads/master | 2023-05-08T05:52:07.003118 | 2021-05-30T08:54:48 | 2021-05-30T08:54:48 | 58,943,465 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,121 | h | /*
* This file is part of the CMaNGOS Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef MANGOS_BYTECONVERTER_H
#define MANGOS_BYTECONVERTER_H
/** ByteConverter reverse your byte order. This is use
for cross platform where they have different endians.
*/
#define MANGOS_LITTLEENDIAN 1
#define MANGOS_BIGENDIAN 0
//#if !defined(MANGOS_ENDIAN)
//# if defined (ACE_BIG_ENDIAN)
//# define MANGOS_ENDIAN MANGOS_BIGENDIAN
//# else // ACE_BYTE_ORDER != ACE_BIG_ENDIAN
//# define MANGOS_ENDIAN MANGOS_LITTLEENDIAN
//# endif // ACE_BYTE_ORDER
//#endif // MANGOS_ENDIAN
//#include <Platform/Define.h>
#include <algorithm>
#include <set>
#include <list>
#include <string>
#include <map>
#include <queue>
#include <sstream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <stdint.h>
/*
typedef std::int64_t int64;
typedef std::int32_t int32;
typedef std::int16_t int16;
typedef std::int8_t int8;
typedef std::uint64_t uint64;
typedef std::uint32_t uint32;
typedef std::uint16_t uint16;
typedef std::uint8_t uint8;
*/
typedef int64_t int64;
typedef int32_t int32;
typedef int16_t int16;
typedef int8_t int8;
typedef uint64_t uint64;
typedef uint32_t uint32;
typedef uint16_t uint16;
typedef uint8_t uint8;
namespace ByteConverter
{
template<size_t T>
inline void convert(char* val)
{
std::swap(*val, *(val + T - 1));
convert < T - 2 > (val + 1);
}
template<> inline void convert<0>(char*) {}
template<> inline void convert<1>(char*) {} // ignore central byte
template<typename T>
inline void apply(T* val)
{
convert<sizeof(T)>((char*)(val));
}
}
//#if MANGOS_ENDIAN == MANGOS_BIGENDIAN
#if (MANGOS_BIGENDIAN==1)
template<typename T> inline void EndianConvert(T& val) { ByteConverter::apply<T>(&val); }
template<typename T> inline void EndianConvertReverse(T&) { }
#else
template<typename T> inline void EndianConvert(T&) { }
template<typename T> inline void EndianConvertReverse(T& val) { ByteConverter::apply<T>(&val); }
#endif
template<typename T> void EndianConvert(T*); // will generate link error
template<typename T> void EndianConvertReverse(T*); // will generate link error
inline void EndianConvert(uint8&) { }
inline void EndianConvert(int8&) { }
inline void EndianConvertReverse(uint8&) { }
inline void EndianConvertReverse(int8&) { }
#endif
| [
"farlongchen@hotmail.com"
] | farlongchen@hotmail.com |
7470a01e38adc5d2bb7816b40fdbea9cb582c460 | 09af3439ebe1276f05111aae72cdc87c0c4d979d | /src/mobile/mobileMain.cpp | ef6912e3408981055457ee3aa63b46418113deed | [] | no_license | josecn88/mobile_dev | 5b43d6ccae324ce197ba77f04f73232eeec340be | ff78fc5e6648e9f8556e2ca3bc7c93c6920e4f78 | refs/heads/master | 2023-07-14T05:20:14.138090 | 2021-08-12T00:21:39 | 2021-08-12T00:21:39 | 350,876,126 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 763 | cpp | /*
* mobileMain.cpp is based on droneMain.cpp
*
* Created by: rsinoue on 16.Jun.2017
* Last Modified: jrsbenevides
*
* Description: This is the main function that maintains the controller running at X Hz,
* where X is assigned in loop_rate(X).
* Updated on: 03/27/2021 by josen
*
*
*/
#include "mobile/mobileSystem.h"
int main(int argc, char **argv)
{
ros::init(argc, argv, "motion_estimation");
try {
MOBILE::System node;
ros::Rate loop_rate(100); // Defines update rate
while (ros::ok())
{
node.control(); //Main control function
ros::spinOnce();
loop_rate.sleep();
}
ros::spin();
}
catch (const std::exception &e) {
ROS_FATAL_STREAM("An error has occurred: " << e.what());
exit(1);
}
return 0;
} | [
"josecn@estudante.ufscar.br"
] | josecn@estudante.ufscar.br |
27cf70877ba143c7f2930e5344ea6b6f6ff2a930 | e06da063bd3dde03de9852c03eff0e7ab9c49e9b | /third_party/include/evpp/windows_port.h | 33a04545a3b4a0c36d4e9737fd2f183a4056fe4d | [] | no_license | crabkaka/crab_rtsp_to_rtmp | 7b4372b0c41de977348cb44f60d74c45838e197c | a27bb0b989b30c745f761a85917d3126682c921a | refs/heads/main | 2023-04-08T12:39:27.401112 | 2021-04-19T13:30:24 | 2021-04-19T13:30:24 | 352,342,448 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,857 | h | #pragma once
// Fix VS compile warning
// 1>c:\program files (x86)\microsoft visual studio 14.0\vc\include\xkeycheck.h(250): fatal error C1189: #error: The C++ Standard Library forbids macroizing keywords. Enable warning C4005 to find the forbidden macro.
#ifdef __cplusplus
#include <iostream>
#endif
//! Define Operation System.
#if ( defined(WIN32) || defined(WIN64) )
# ifndef H_OS_WINDOWS
# define H_OS_WINDOWS
# endif
# ifndef H_WINDOWS_API
# define H_WINDOWS_API
# endif
#endif
#ifdef H_OS_WINDOWS
#define usleep(us) Sleep((us)/1000)
#define snprintf _snprintf
#define thread_local __declspec(thread)
#define strcasecmp _stricmp
#define strncasecmp _strnicmp
#endif
#ifdef H_OS_WINDOWS
#pragma warning( disable: 4005 ) // warning C4005 : 'va_copy' : macro redefinition
#pragma warning( disable: 4251 )
#pragma warning( disable: 4996 ) // warning C4996: 'strerror': This function or variable may be unsafe. Consider using strerror_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
#pragma warning( disable: 4244 4251 4355 4715 4800 4996 4005 4819)
#pragma warning( disable: 4530 ) // C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\include\xlocale(341): warning C4530: C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc
#pragma warning( disable: 4577 ) // C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\include\exception(359): warning C4577: 'noexcept' used with no exception handling mode specified; termination on exception is not guaranteed. Specify /EHsc
#pragma warning( disable: 4503 ) // c:\program files (x86)\microsoft visual studio 14.0\vc\include\functional(357): warning C4503: '__LINE__Var': decorated name length exceeded, name was truncated
#endif
// get rid of Windows/Linux inconsistencies
#ifdef H_OS_WINDOWS
# ifndef PRIu64
# define PRIu64 "I64u"
# endif
#else
# ifndef PRIu64
# define PRIu64 "lu"
# endif
#endif
//! Module symbol export
// #ifdef H_WINDOWS_API
// # ifndef H_STATIC_LIB_EVPP
// # ifdef EVPP_EXPORTS
// # define EVPP_EXPORT __declspec(dllexport)
// # else
// # define EVPP_EXPORT __declspec(dllimport)
// # endif
// # else
// # define EVPP_EXPORT
// # endif
// #else
// # define EVPP_EXPORT
// #endif
#define EVPP_EXPORT
// We must link against these libraries on windows platform for Visual Studio IDE
#ifdef _WIN32
#ifndef EVPP_EXPORTS
#pragma comment(lib, "evpp_static.lib")
#endif
#pragma comment(lib, "Ws2_32.lib")
//#pragma comment(lib, "glog.lib")
#pragma comment(lib, "event.lib")
#ifndef H_LIBEVENT_VERSION_14
#pragma comment(lib, "event_core.lib") // libevent2.0
#pragma comment(lib, "event_extra.lib") // libevent2.0
#endif
#endif
#ifdef H_OS_WINDOWS
#define __PRETTY_FUNCTION__ __FUNCTION__
#endif
| [
"zb@qq.com"
] | zb@qq.com |
f3db3f63c9eeb201373741fbc7c5247513466b2c | c55d33ff376cd6ff07333d6ee0be053f62de9a76 | /src/caddress.h | d501e79e9a5628488dcf1158d5f7ca45fbb3548c | [
"MIT",
"BSD-3-Clause"
] | permissive | DigitalNoteXDN/DigitalNote-2 | 1d306c47ee962f6266be5caa6b03e4f96c3f179c | fb73be8032491364892fb90b1c696105034f74e9 | refs/heads/master | 2023-04-13T18:02:19.719011 | 2023-04-07T20:52:26 | 2023-04-07T20:52:26 | 168,789,998 | 11 | 27 | MIT | 2023-04-07T20:52:27 | 2019-02-02T03:26:35 | C++ | UTF-8 | C++ | false | false | 690 | h | #ifndef CADDRESS_H
#define CADDRESS_H
#include "protocol.h"
#include "net/cservice.h"
/** A CService with information about it as peer */
class CAddress : public CService
{
// TODO: make private (improves encapsulation)
public:
uint64_t nServices;
unsigned int nTime; // disk and network only
int64_t nLastTry; // memory only
CAddress();
explicit CAddress(CService ipIn, uint64_t nServicesIn=NODE_NETWORK);
void Init();
unsigned int GetSerializeSize(int nType, int nVersion) const;
template<typename Stream>
void Serialize(Stream& s, int nType, int nVersion) const;
template<typename Stream>
void Unserialize(Stream& s, int nType, int nVersion);
};
#endif // CADDRESS_H
| [
"admin@ludoruisch.nl"
] | admin@ludoruisch.nl |
542fe1ed2f21faa999f662bb5fe5a0970b2480a9 | 1384d6be3925905ace9a9a768c512ca6438a5386 | /计蒜客/k倍区间.cpp | c5c9c389b5c198ef41fd95d34f7776020107477c | [] | no_license | PPPPro/AcmPractise | 0d816911d55bc032bb2e049c722f028a8abe3694 | b4f7df26c1ad8f726a20df9edba9ac2d7296624c | refs/heads/master | 2020-04-13T03:47:29.380308 | 2018-12-24T02:43:12 | 2018-12-24T02:43:12 | 162,942,316 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 333 | cpp | #include<iostream>
using namespace std;
const int Max = 100000;
int main(){
int n,k,a[Max],i,j,cnt = 0,l,tmp;
cin >> n >> k;
for(i = 1; i <= n; i++)
cin >> a[i];
for(i = 1; i <= n; i++){
for(j = i; j <= n; j++){
tmp = 0;
for(l = 1; l <= n-j; l++){
tmp += a[i];
}
if(a[i]%k == 0)cnt++;
}
}
cout << cnt;
}
| [
"zanhui.fan@Hotmail.com"
] | zanhui.fan@Hotmail.com |
1ae3d4bc8f60d37b1fbdfdf2e0d276edc200f902 | 55d9c215d110a28806c7cd75bfa54f3670b8bb8a | /Classes/CParticle.h | 418582c5afb0567d3b3f24188de32857c37047bf | [] | no_license | ChaoTzuJung/ParticleSystem | 9c2c30fdc8b449a53a14801f5736935f684039ec | 251a0248bdd574da0e581b3102ebea9b764fbd3b | refs/heads/master | 2021-01-23T04:40:01.737311 | 2017-03-26T17:25:56 | 2017-03-26T17:25:56 | 86,234,058 | 0 | 0 | null | null | null | null | BIG5 | C++ | false | false | 2,631 | h | #ifndef __CPARTICLE_H__
#define __CPARTICLE_H__
#define STAY_FOR_TWOSECONDS 0 // 在手指滑過的地方產生 particle
#define RANDOMS_FALLING 1 // 在手指滑過的地方往下產生 particle
#define FREE_FLY 2 // 在手指滑過的地方任意向四方產生 particle
#define EXPLOSION 3 // 噴射出圓形的煙火
#define HEARTSHAPE 4 // 噴射出心型的煙火
#define BUTTERFLYSHAPE 5 // 噴射出蝴蝶外型的煙火
#define ROSE 6
#define ROSE2 7
#define ROSE3 8
#define EMITTER_DEFAULT 99
#define FIREWORK 9
#include "cocos2d.h"
class CParticle
{
private:
cocos2d::Sprite *_Particle; // 分子本體
cocos2d::Sprite *_Particle_1;// 分子殘影75%
cocos2d::Sprite *_Particle_2;// 分子殘影50%
cocos2d::Sprite *_Particle_3;// 分子殘影25%
cocos2d::Point _emitterPt;// Emitter 的位置
cocos2d::Point _OldPos; // 分子前一個位置
cocos2d::Point _Pos; // 分子目前的位置
cocos2d::Point _Direction; // 分子目前的運動方向，單位向量
float _fVelocity; // 分子的速度
float _fLifeTime; // 生命週期
float _fIntensity;// 分子能量的最大值，通常用於改變分子的顏色
float _fOpacity; // 目前分子的透明度
float _fSpin; // 分子的旋轉量
float _fSize; // 分子的大小
float _fGravity; // 分子的重力
float degree;
float _fRed;
float _fGreen;
float _fBlue;
float _fWind;
float _fSpread;
float _fDir;
cocos2d::Color3B _color; // 分子的顏色
// 時間
float _fElapsedTime; // 分子從顯示到目前為止的時間
float _fDelayTime; // 分子顯示前的延遲時間
// 行為模式
int _iType;
// 顯示與否
bool _bVisible;
public:
CParticle();
void setParticle(const char *pngName, cocos2d::Layer &inlayer);
bool doStep(float dt);
void setPosition(const cocos2d::Point &inPos);
void setColor(cocos2d::Color3B &color) { _color = color;}
void setBehavior(int iType); // 設定分子產生的起始行為模式
void setVisible();
void setGravity(const float fGravity);
void setVelocity(const float v) { _fVelocity = v; }
void setLifetime(const float lt);
void setDirection(const cocos2d::Point pt) { _Direction = pt; }
void setSize(float s) { _fSize = s; _Particle->setScale(_fSize); }
void setOpacity(float a) { _fOpacity = a; };
void setSpin1(float fSpin);
void setRed(const float fRed) { _fRed = fRed; };
void setGreen(const float fGreen) { _fGreen = fGreen; };
void setBlue(const float fBlue) { _fBlue = fBlue; };
void setWind(const float fWind);
void setSpread(const float _fSpread);
void setDir(const float fDir);
//void setSpecial(int a);
};
#endif | [
"s110319022@stu.ntue.edu.tw"
] | s110319022@stu.ntue.edu.tw |
62a6522fa13d2568542eb74c15f0f400bbebd082 | 81b9b8ae0e9cc6cf320a95cf373594599d81fe12 | /Base/FileChangeWatcher/FileChangeWatcher.h | d10002cafc7fe504a7fccb788388a3a664d83781 | [] | no_license | mouchtaris/delta-linux | 1041b9dcc549bda2858dcedbc61087bb73817415 | cca8bd3c1646957cb3203191bb03e80d52f30631 | HEAD | 2016-09-01T19:28:43.257785 | 2014-09-02T05:00:54 | 2014-09-02T05:00:54 | 23,297,561 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 939 | h | /**
* FileChangeWatcher.h
*
* Ioannis Lilis <lilis@ics.forth.gr>
* July 2009
*/
#ifndef FILE_CHANGE_WATCHER_H
#define FILE_CHANGE_WATCHER_H
#include "Common.h"
#include "LibraryAPIDecls.h"
#include "Singleton.h"
#include <map>
#include <boost/function.hpp>
namespace util {
class DirectoryWatcher;
////////////////////////////////////////////////////////////////////////
class _BASE_API FileChangeWatcher : public util::Singleton {
DECLARE_SINGLETON(FileChangeWatcher);
public:
typedef boost::function<void (void)> Callback;
unsigned long long Register(const String& uri, const Callback& callback);
void Cancel (const String& uri, unsigned long long watch);
private:
typedef std::map<String, DirectoryWatcher*> WatcherMap;
WatcherMap watchers;
};
////////////////////////////////////////////////////////////////////////
} // namespace util
#endif // FILE_CHANGE_WATCHER_H | [
"lilis@09f5c9fd-6ff0-f344-b9e4-4de1b5e69ea1"
] | lilis@09f5c9fd-6ff0-f344-b9e4-4de1b5e69ea1 |
8c46668bf90f8eba9918f1c99516081b55377d41 | 24a0c4835a70f852c2a5c0f1890afeedd6573e19 | /tools/aidl/tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/StructuredParcelable.cpp | cc0f2f1b69412a3bd482d131dcd5264501a410a1 | [
"Apache-2.0"
] | permissive | jiangshide/android-system | cbe903883b4334be718f98b47910640515f1190e | ef92d4e47f51e84d2e7ed3affbeadabeafde2cd2 | refs/heads/main | 2023-06-09T01:52:12.061540 | 2021-06-21T03:00:05 | 2021-06-21T03:00:05 | 378,790,086 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 27,726 | cpp | #include <android/aidl/tests/StructuredParcelable.h>
namespace android {
namespace aidl {
namespace tests {
::android::status_t StructuredParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) {
::android::status_t _aidl_ret_status = ::android::OK;
[[maybe_unused]] size_t _aidl_start_pos = _aidl_parcel->dataPosition();
int32_t _aidl_parcelable_raw_size = _aidl_parcel->readInt32();
if (_aidl_parcelable_raw_size < 0) return ::android::BAD_VALUE;
[[maybe_unused]] size_t _aidl_parcelable_size = static_cast<size_t>(_aidl_parcelable_raw_size);
if (_aidl_start_pos > SIZE_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE;
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32Vector(&shouldContainThreeFs);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(&f);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&shouldBeJerry);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast<int8_t *>(&shouldBeByteBar));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&shouldBeIntBar));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt64(reinterpret_cast<int64_t *>(&shouldBeLongBar));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readEnumVector(&shouldContainTwoByteFoos);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readEnumVector(&shouldContainTwoIntFoos);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readEnumVector(&shouldContainTwoLongFoos);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readString16(&stringDefaultsToFoo);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readByte(&byteDefaultsToFour);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(&intDefaultsToFive);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt64(&longDefaultsToNegativeSeven);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readBool(&booleanDefaultsToTrue);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readChar(&charDefaultsToC);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readFloat(&floatDefaultsToPi);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readDouble(&doubleWithDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32Vector(&arrayDefaultsTo123);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32Vector(&arrayDefaultsToEmpty);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readBool(&boolDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readByte(&byteDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(&intDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt64(&longDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readFloat(&floatDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readDouble(&doubleDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readDouble(&checkDoubleFromFloat);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readString16Vector(&checkStringArray1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readUtf8VectorFromUtf16Vector(&checkStringArray2);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(&int32_min);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(&int32_max);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt64(&int64_max);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(&hexInt32_neg_1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&ibinder);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32Vector(&int32_1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt64Vector(&int64_1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(&hexInt32_pos_1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(&hexInt64_pos_1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&const_exprs_1));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&const_exprs_2));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&const_exprs_3));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&const_exprs_4));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&const_exprs_5));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&const_exprs_6));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&const_exprs_7));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&const_exprs_8));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&const_exprs_9));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&const_exprs_10));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&addString1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&addString2);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(&shouldSetBit0AndBit2);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readParcelable(&u);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readParcelable(&shouldBeConstS1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast<int32_t *>(&defaultWithFoo));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
return _aidl_ret_status;
}
::android::status_t StructuredParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const {
::android::status_t _aidl_ret_status = ::android::OK;
auto _aidl_start_pos = _aidl_parcel->dataPosition();
_aidl_parcel->writeInt32(0);
_aidl_ret_status = _aidl_parcel->writeInt32Vector(shouldContainThreeFs);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(f);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(shouldBeJerry);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeByte(static_cast<int8_t>(shouldBeByteBar));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(shouldBeIntBar));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt64(static_cast<int64_t>(shouldBeLongBar));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeEnumVector(shouldContainTwoByteFoos);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeEnumVector(shouldContainTwoIntFoos);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeEnumVector(shouldContainTwoLongFoos);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeString16(stringDefaultsToFoo);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeByte(byteDefaultsToFour);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(intDefaultsToFive);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt64(longDefaultsToNegativeSeven);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeBool(booleanDefaultsToTrue);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeChar(charDefaultsToC);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeFloat(floatDefaultsToPi);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeDouble(doubleWithDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32Vector(arrayDefaultsTo123);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32Vector(arrayDefaultsToEmpty);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeBool(boolDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeByte(byteDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(intDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt64(longDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeFloat(floatDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeDouble(doubleDefault);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeDouble(checkDoubleFromFloat);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeString16Vector(checkStringArray1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeUtf8VectorAsUtf16Vector(checkStringArray2);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(int32_min);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(int32_max);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt64(int64_max);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(hexInt32_neg_1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeStrongBinder(ibinder);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32Vector(int32_1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt64Vector(int64_1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(hexInt32_pos_1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(hexInt64_pos_1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(const_exprs_1));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(const_exprs_2));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(const_exprs_3));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(const_exprs_4));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(const_exprs_5));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(const_exprs_6));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(const_exprs_7));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(const_exprs_8));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(const_exprs_9));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(const_exprs_10));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(addString1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(addString2);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(shouldSetBit0AndBit2);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeNullableParcelable(u);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeNullableParcelable(shouldBeConstS1);
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
_aidl_ret_status = _aidl_parcel->writeInt32(static_cast<int32_t>(defaultWithFoo));
if (((_aidl_ret_status) != (::android::OK))) {
return _aidl_ret_status;
}
auto _aidl_end_pos = _aidl_parcel->dataPosition();
_aidl_parcel->setDataPosition(_aidl_start_pos);
_aidl_parcel->writeInt32(_aidl_end_pos - _aidl_start_pos);
_aidl_parcel->setDataPosition(_aidl_end_pos);
return _aidl_ret_status;
}
} // namespace tests
} // namespace aidl
} // namespace android
| [
"jiangshide@zhihu.com"
] | jiangshide@zhihu.com |
4709977a68bb66c38f3a2980715149416ae9d92f | cd17244bdea3cf5ea9ce9d32ca00b98dbaec9d7a | /递归/revArray.cpp | 99cea4c48cdcae780c143303744fa8b47b2eb0e6 | [] | no_license | shzcsgithub2018/code | 9fab4cf569e71425a637a70b892f63558334d73f | c2d643bfa2ae814243e6b3c0eeb2083a8459e4a6 | refs/heads/master | 2020-04-21T16:08:40.301576 | 2019-06-27T13:59:36 | 2019-06-27T13:59:36 | 169,690,865 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 461 | cpp | /*
**Source：http://pkuic.openjudge.cn/dg1/1/
**Auther：Shz
**Data : February 8, 2019
*/
#include<iostream>
using namespace std;
#define MAX 105
void revSave(int a[], int n) {
int tmp;
scanf("%d", &tmp);
n--;
if (n != 0)
revSave(a, n);
a[n] = tmp;
}
int main() {
int n;
int a[MAX];
scanf("%d", &n);
revSave(a,n);
for (int i = 0; i < n; i++)
cout << a[i] << " ";
cout << '\n';
return 0;
} | [
"1919062854@qq.com"
] | 1919062854@qq.com |
d68c60a7bf55a1fa94ad0092d8db15bc2da4bb77 | 3e4fd5153015d03f147e0f105db08e4cf6589d36 | /Cpp/SDK/Skill_DoubleCross_functions.cpp | e7970dcb0c739c2e84622fb365b5955fabf676e9 | [] | no_license | zH4x-SDK/zTorchlight3-SDK | a96f50b84e6b59ccc351634c5cea48caa0d74075 | 24135ee60874de5fd3f412e60ddc9018de32a95c | refs/heads/main | 2023-07-20T12:17:14.732705 | 2021-08-27T13:59:21 | 2021-08-27T13:59:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,406 | cpp | // Name: Torchlight3, Version: 1.0.0
#include "../pch.h"
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------
// Function Skill_DoubleCross.Skill_DoubleCross_C.OnSkillRemoved
// (Event, Public, BlueprintCallable, BlueprintEvent, Const)
// Parameters:
// class AActor* Actor (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
void USkill_DoubleCross_C::OnSkillRemoved(class AActor* Actor)
{
static auto fn = UObject::FindObject<UFunction>("Function Skill_DoubleCross.Skill_DoubleCross_C.OnSkillRemoved");
USkill_DoubleCross_C_OnSkillRemoved_Params params;
params.Actor = Actor;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Skill_DoubleCross.Skill_DoubleCross_C.OnSkillActorOverlap
// (Event, Public, BlueprintCallable, BlueprintEvent, Const)
// Parameters:
// class AActor* Instigator (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor* Actor (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class ASkillShape* Shape (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool bIsPrimaryTarget (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor)
// int SkillInstanceId (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
void USkill_DoubleCross_C::OnSkillActorOverlap(class AActor* Instigator, class AActor* Actor, class ASkillShape* Shape, bool bIsPrimaryTarget, int SkillInstanceId)
{
static auto fn = UObject::FindObject<UFunction>("Function Skill_DoubleCross.Skill_DoubleCross_C.OnSkillActorOverlap");
USkill_DoubleCross_C_OnSkillActorOverlap_Params params;
params.Instigator = Instigator;
params.Actor = Actor;
params.Shape = Shape;
params.bIsPrimaryTarget = bIsPrimaryTarget;
params.SkillInstanceId = SkillInstanceId;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Skill_DoubleCross.Skill_DoubleCross_C.OnSkillEventHit01
// (Event, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintEvent, Const)
// Parameters:
// class AActor* Actor (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor* TargetActor (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FVector TargetLocation (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int SkillInstanceId (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor)
bool USkill_DoubleCross_C::OnSkillEventHit01(class AActor* Actor, class AActor* TargetActor, const struct FVector& TargetLocation, int SkillInstanceId)
{
static auto fn = UObject::FindObject<UFunction>("Function Skill_DoubleCross.Skill_DoubleCross_C.OnSkillEventHit01");
USkill_DoubleCross_C_OnSkillEventHit01_Params params;
params.Actor = Actor;
params.TargetActor = TargetActor;
params.TargetLocation = TargetLocation;
params.SkillInstanceId = SkillInstanceId;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function Skill_DoubleCross.Skill_DoubleCross_C.GetSkillDescription
// (Event, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintEvent, Const)
// Parameters:
// class AActor* Actor (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int SkillLevel (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
struct FText USkill_DoubleCross_C::GetSkillDescription(class AActor* Actor, int SkillLevel)
{
static auto fn = UObject::FindObject<UFunction>("Function Skill_DoubleCross.Skill_DoubleCross_C.GetSkillDescription");
USkill_DoubleCross_C_GetSkillDescription_Params params;
params.Actor = Actor;
params.SkillLevel = SkillLevel;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"zp2kshield@gmail.com"
] | zp2kshield@gmail.com |
497c04747e4e33d2c77ae19fdfc4c88688f17e91 | 22f219dd5ec92b09060fefff9a78d07820518b25 | /MultithreadedTests/precompile.h | 2798ff8a7c39108b974e0b3a7035e42c47e812c0 | [] | no_license | EddieB0711/MultithreadedTests | f84ae173b98fb33237a000bf5ed3246213a1ea14 | b64f9abc8a73ac5bd6d74d5539b2c84d35bf8bba | refs/heads/master | 2021-01-10T17:12:52.201733 | 2016-03-19T17:27:11 | 2016-03-19T17:27:11 | 52,749,178 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 168 | h | #pragma once
#include <windows.h>
#include <memory>
#include <string>
#include <vector>
#include <map>
#include "Trace.h"
#include "time_something.h"
#pragma hdrstop | [
"eddie.boyle7@gmail.com"
] | eddie.boyle7@gmail.com |
af6436724c3e2d60011e19e8f03f4190aa257188 | 4ad3b3d49121bcea76d5e71a28b4de02d7f6a76f | /RWVector/src/main.cpp | 87770fd6ef79d62b5d6cf7e092450b0dab8f0640 | [
"MIT"
] | permissive | GamesTrap/LearnCPP | 28fe7df820b83d8211a24a96c5840586af5b4dd5 | 710b24876f61e1033aaa0502fc4508250de717c3 | refs/heads/master | 2020-03-25T07:15:57.828652 | 2018-12-26T00:33:58 | 2018-12-26T00:33:58 | 143,551,049 | 7 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,070 | cpp | #include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <cassert>
template<typename T>
void WriteVector(std::string_view filename, const std::vector<T>& v)
{
std::ofstream dest(filename.data(), std::ios::binary);
if (!dest)
throw std::ios::failure(__FILE__ ":" + std::to_string(__LINE__));
dest.write(reinterpret_cast<const char*>(v.data()), v.size() * sizeof(T));
}
template<typename T>
void ReadVector(std::string_view filename, std::vector<T>& v)
{
std::ifstream source(filename.data(), std::ios::binary);
if (!source)
throw std::ios::failure(__FILE__ ":" + std::to_string(__LINE__));
source.read(reinterpret_cast<char*>(v.data()), v.size() * sizeof(T));
}
int main()
{
std::string_view filename("binaryData.bin");
std::vector<double> v1{ 1.27,3.4,5.678,9.01234,100.836 };
WriteVector(filename, v1); //Write v1
decltype(v1) v2(v1.size(), 0.0); //Initialize v2 with 0
ReadVector(filename, v2); //Read v2
assert(v1 == v2); //Check for equality
std::cout << "Press Enter to continue . . . ";
std::cin.get();
return 0;
} | [
"GamesTrap@web.de"
] | GamesTrap@web.de |
d2c101b9d57f24c5a8c6a1d4044f99638a86bdd0 | 69e3a6422da5fc1a81b68c563fd6e41f614abfb2 | /employee.cpp | adf8f9256ebdd9b48b7b84d7d66c3d8fd00df024 | [] | no_license | akashcaptain/cpp | 34e2a65ee6d360f729836fea82746eab7d0ce81a | f6b277fcd3dbae52e576bd4d875617f9eb9d1037 | refs/heads/master | 2023-05-31T08:01:49.220320 | 2021-03-05T03:50:18 | 2021-03-05T03:50:18 | 344,686,680 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,017 | cpp | /*Here we have to be see friend function calling and private member element
and public member function */
#include<iostream>
#include<cstring>
using namespace std;
class employee{
char name[30]; // private data
int salary;
public :
void getname(char *n);
void getsalary(int s);
void showname(char *n);
int showsalary();
friend void friendfunction(employee s); // friend function declearation
};
void employee :: getname(char *n){
strcpy(name,n);
}
void employee :: showname(char *n){
strcpy(n,name);
}
void employee :: getsalary(int s){
salary=s;
}
int employee :: showsalary(){
return salary;
}
void friendfunction(employee s){
cout << "\nHere is friend function " << endl;
cout << "Employname " << s.name;
cout << "Salary " << s.salary;
}
int main()
{
employee e;char name[30];
e.getname("akash chakraborty");
e.getsalary(50000);
e.showname(name);
cout << "Employee name is " << name << endl;
cout << "Employee salary is " << e.showsalary();
friendfunction(e);
return 0;
}
| [
"akash.online98@gmail.com"
] | akash.online98@gmail.com |
ef41f257c330d2e2118726c652f36975b03bdce1 | 63f3ee6c75b29d155c7c38660852d2f4284da727 | /queueArray.cpp | a3bdd6eb583a621c5cc66ba755aba25463998c83 | [] | no_license | msk4862/Data-Structures-Programs | ae5ade73fd493fb23d9e8e1663359c47fdd6f62c | a02585d0e5a19a2d9b919634cba141f6f64ea3cd | refs/heads/master | 2021-08-29T08:16:30.179155 | 2017-12-13T14:35:24 | 2017-12-13T14:35:24 | 114,131,476 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,489 | cpp | #include<iostream>
#include<cstdlib>
using namespace std;
template<class T>
class queue
{
T *q;
int rear,front;
int SIZE;
public:
queue(int s);
void EnQueue(int x);
void DeQueue();
void display();
};
template<class T>
queue<T>::queue(int s) {
rear=-1;
front=-1;
SIZE = s;
q = new int[s];
}
template<class T>
void queue<T>:: EnQueue(int x) {
if((front==0 && rear==SIZE-1) || (rear == front-1)) {
cout <<"\n\nQueue Overflow!!!";
return;
}
//first element
if(front == -1) {
front = 0;
}
rear = (rear+1) % SIZE;
q[rear]=x;
cout<<x<<" inserted successfully!!!";
}
template<class T>
void queue<T>:: DeQueue() {
if (front == -1) {
cout <<"\n\nQueue Underflow!!!";
return;
}
cout<<q[front]<<" deleted successfully!!!";
front = (front + 1) % SIZE;
}
template<class T>
void queue<T>:: display() {
if(front==-1) {
cout <<"\n\nQueue is Empty!!!!";
return;
}
cout<<endl<<"Your Queue: ";
if(rear >= front) {
for(int i = front; i <= rear; i++)
cout <<q[i]<<" ";
}
else {
for(int i = front; i < SIZE; i++)
cout <<q[i]<<" ";
for(int i = 0; i <= rear; i++)
cout <<q[i]<<" ";
}
}
int main()
{
int ch;
int d;
queue<int> q(5);
while(1)
{
cout <<"\n\n\n1.Enqueue \n2.Dequeue \n3.Display \n4.Exit\n\nEnter your choice: ";
cin >> ch;
switch(ch)
{
case 1: cout <<"Enter the element: ";
cin >> d;
q.EnQueue(d);
break;
case 2: q.DeQueue();
break;
case 3: q.display();
break;
case 4: exit(0);
}
}
return 0;
}
| [
"msk4862@gmail.com"
] | msk4862@gmail.com |
57883a8e82b8e834d5f711ebc0903ce3b7658c3e | 891bfc38e6e85b643afe683ac69942634ec2dde7 | /services/tracing/perfetto/json_trace_exporter.cc | 3bc386d9c412f3ef0172b1cbec27fa2a71fee043 | [
"BSD-3-Clause"
] | permissive | siliu1/chromium | 6635bef82e896f2fee63dcd5f1182c289b35edb4 | b9310a104d7cf73c7807963089a77e287ef4b19b | refs/heads/master | 2023-03-18T14:13:43.241848 | 2019-02-13T19:56:46 | 2019-02-13T19:56:46 | 170,571,164 | 0 | 0 | NOASSERTION | 2019-02-14T04:28:44 | 2019-02-13T20:01:41 | null | UTF-8 | C++ | false | false | 15,589 | cc | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "services/tracing/perfetto/json_trace_exporter.h"
#include <unordered_map>
#include <utility>
#include "base/format_macros.h"
#include "base/json/json_reader.h"
#include "base/json/json_writer.h"
#include "base/json/string_escape.h"
#include "base/logging.h"
#include "base/strings/stringprintf.h"
#include "base/trace_event/trace_event.h"
#include "third_party/perfetto/protos/perfetto/trace/chrome/chrome_trace_event.pbzero.h"
#include "third_party/perfetto/protos/perfetto/trace/chrome/chrome_trace_packet.pb.h"
using TraceEvent = base::trace_event::TraceEvent;
namespace tracing {
namespace {
const size_t kTraceEventBufferSizeInBytes = 100 * 1024;
void AppendProtoArrayAsJSON(std::string* out,
const perfetto::protos::ChromeTracedValue& array);
void AppendProtoValueAsJSON(std::string* out,
const perfetto::protos::ChromeTracedValue& value) {
base::trace_event::TraceEvent::TraceValue json_value;
if (value.has_int_value()) {
json_value.as_int = value.int_value();
TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_INT, json_value, out);
} else if (value.has_double_value()) {
json_value.as_double = value.double_value();
TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_DOUBLE, json_value, out);
} else if (value.has_bool_value()) {
json_value.as_bool = value.bool_value();
TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_BOOL, json_value, out);
} else if (value.has_string_value()) {
json_value.as_string = value.string_value().c_str();
TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_STRING, json_value, out);
} else if (value.has_nested_type()) {
if (value.nested_type() == perfetto::protos::ChromeTracedValue::ARRAY) {
AppendProtoArrayAsJSON(out, value);
return;
} else if (value.nested_type() ==
perfetto::protos::ChromeTracedValue::DICT) {
AppendProtoDictAsJSON(out, value);
} else {
NOTREACHED();
}
} else {
NOTREACHED();
}
}
void AppendProtoArrayAsJSON(std::string* out,
const perfetto::protos::ChromeTracedValue& array) {
out->append("[");
bool is_first_entry = true;
for (auto& value : array.array_values()) {
if (!is_first_entry) {
out->append(",");
} else {
is_first_entry = false;
}
AppendProtoValueAsJSON(out, value);
}
out->append("]");
}
const char* GetStringFromStringTable(
const std::unordered_map<int, std::string>& string_table,
int index) {
auto it = string_table.find(index);
DCHECK(it != string_table.end());
return it->second.c_str();
}
void OutputJSONFromTraceEventProto(
const perfetto::protos::ChromeTraceEvent& event,
std::string* out,
const std::unordered_map<int, std::string>& string_table) {
char phase = static_cast<char>(event.phase());
const char* name =
event.has_name_index()
? GetStringFromStringTable(string_table, event.name_index())
: event.name().c_str();
const char* category_group_name =
event.has_category_group_name_index()
? GetStringFromStringTable(string_table,
event.category_group_name_index())
: event.category_group_name().c_str();
base::StringAppendF(out,
"{\"pid\":%i,\"tid\":%i,\"ts\":%" PRId64
",\"ph\":\"%c\",\"cat\":\"%s\",\"name\":",
event.process_id(), event.thread_id(), event.timestamp(),
phase, category_group_name);
base::EscapeJSONString(name, true, out);
if (event.has_duration()) {
base::StringAppendF(out, ",\"dur\":%" PRId64, event.duration());
}
if (event.has_thread_duration()) {
base::StringAppendF(out, ",\"tdur\":%" PRId64, event.thread_duration());
}
if (event.has_thread_timestamp()) {
base::StringAppendF(out, ",\"tts\":%" PRId64, event.thread_timestamp());
}
// Output async tts marker field if flag is set.
if (event.flags() & TRACE_EVENT_FLAG_ASYNC_TTS) {
base::StringAppendF(out, ", \"use_async_tts\":1");
}
// If id_ is set, print it out as a hex string so we don't loose any
// bits (it might be a 64-bit pointer).
unsigned int id_flags =
event.flags() & (TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_HAS_LOCAL_ID |
TRACE_EVENT_FLAG_HAS_GLOBAL_ID);
if (id_flags) {
if (event.has_scope()) {
base::StringAppendF(out, ",\"scope\":\"%s\"", event.scope().c_str());
}
DCHECK(event.has_id());
switch (id_flags) {
case TRACE_EVENT_FLAG_HAS_ID:
base::StringAppendF(out, ",\"id\":\"0x%" PRIx64 "\"",
static_cast<uint64_t>(event.id()));
break;
case TRACE_EVENT_FLAG_HAS_LOCAL_ID:
base::StringAppendF(out, ",\"id2\":{\"local\":\"0x%" PRIx64 "\"}",
static_cast<uint64_t>(event.id()));
break;
case TRACE_EVENT_FLAG_HAS_GLOBAL_ID:
base::StringAppendF(out, ",\"id2\":{\"global\":\"0x%" PRIx64 "\"}",
static_cast<uint64_t>(event.id()));
break;
default:
NOTREACHED() << "More than one of the ID flags are set";
break;
}
}
if (event.flags() & TRACE_EVENT_FLAG_BIND_TO_ENCLOSING)
base::StringAppendF(out, ",\"bp\":\"e\"");
if (event.has_bind_id()) {
base::StringAppendF(out, ",\"bind_id\":\"0x%" PRIx64 "\"",
static_cast<uint64_t>(event.bind_id()));
}
if (event.flags() & TRACE_EVENT_FLAG_FLOW_IN)
base::StringAppendF(out, ",\"flow_in\":true");
if (event.flags() & TRACE_EVENT_FLAG_FLOW_OUT)
base::StringAppendF(out, ",\"flow_out\":true");
// Instant events also output their scope.
if (phase == TRACE_EVENT_PHASE_INSTANT) {
char scope = '?';
switch (event.flags() & TRACE_EVENT_FLAG_SCOPE_MASK) {
case TRACE_EVENT_SCOPE_GLOBAL:
scope = TRACE_EVENT_SCOPE_NAME_GLOBAL;
break;
case TRACE_EVENT_SCOPE_PROCESS:
scope = TRACE_EVENT_SCOPE_NAME_PROCESS;
break;
case TRACE_EVENT_SCOPE_THREAD:
scope = TRACE_EVENT_SCOPE_NAME_THREAD;
break;
}
base::StringAppendF(out, ",\"s\":\"%c\"", scope);
}
*out += ",\"args\":{";
for (int i = 0; i < event.args_size(); ++i) {
auto& arg = event.args(i);
if (i > 0) {
*out += ",";
}
*out += "\"";
*out += arg.has_name_index()
? GetStringFromStringTable(string_table, arg.name_index())
: arg.name();
*out += "\":";
TraceEvent::TraceValue value;
if (arg.has_bool_value()) {
value.as_bool = arg.bool_value();
TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_BOOL, value, out);
continue;
}
if (arg.has_uint_value()) {
value.as_uint = arg.uint_value();
TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_UINT, value, out);
continue;
}
if (arg.has_int_value()) {
value.as_int = arg.int_value();
TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_INT, value, out);
continue;
}
if (arg.has_double_value()) {
value.as_double = arg.double_value();
TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_DOUBLE, value, out);
continue;
}
if (arg.has_pointer_value()) {
value.as_pointer = reinterpret_cast<void*>(arg.pointer_value());
TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_POINTER, value, out);
continue;
}
if (arg.has_string_value()) {
std::string str = arg.string_value();
value.as_string = &str[0];
TraceEvent::AppendValueAsJSON(TRACE_VALUE_TYPE_STRING, value, out);
continue;
}
if (arg.has_json_value()) {
*out += arg.json_value();
continue;
}
if (arg.has_traced_value()) {
AppendProtoDictAsJSON(out, arg.traced_value());
continue;
}
NOTREACHED();
}
*out += "}}";
}
std::unique_ptr<base::DictionaryValue> ConvertTraceStatsToDict(
const perfetto::protos::TraceStats& trace_stats) {
auto dict = std::make_unique<base::DictionaryValue>();
dict->SetInteger("producers_connected", trace_stats.producers_connected());
dict->SetInteger("producers_seen", trace_stats.producers_seen());
dict->SetInteger("data_sources_registered",
trace_stats.data_sources_registered());
dict->SetInteger("data_sources_seen", trace_stats.data_sources_seen());
dict->SetInteger("tracing_sessions", trace_stats.tracing_sessions());
dict->SetInteger("total_buffers", trace_stats.total_buffers());
auto buf_list = std::make_unique<base::ListValue>();
for (const auto& buf_stats : trace_stats.buffer_stats()) {
base::Value buf_value(base::Value::Type::DICTIONARY);
base::DictionaryValue* buf_dict;
buf_value.GetAsDictionary(&buf_dict);
buf_dict->SetInteger("buffer_size", buf_stats.buffer_size());
buf_dict->SetInteger("bytes_written", buf_stats.bytes_written());
buf_dict->SetInteger("bytes_overwritten", buf_stats.bytes_overwritten());
buf_dict->SetInteger("bytes_read", buf_stats.bytes_read());
buf_dict->SetInteger("padding_bytes_written",
buf_stats.padding_bytes_written());
buf_dict->SetInteger("padding_bytes_cleared",
buf_stats.padding_bytes_cleared());
buf_dict->SetInteger("chunks_written", buf_stats.chunks_written());
buf_dict->SetInteger("chunks_rewritten", buf_stats.chunks_rewritten());
buf_dict->SetInteger("chunks_overwritten", buf_stats.chunks_overwritten());
buf_dict->SetInteger("chunks_discarded", buf_stats.chunks_discarded());
buf_dict->SetInteger("chunks_read", buf_stats.chunks_read());
buf_dict->SetInteger("chunks_committed_out_of_order",
buf_stats.chunks_committed_out_of_order());
buf_dict->SetInteger("write_wrap_count", buf_stats.write_wrap_count());
buf_dict->SetInteger("patches_succeeded", buf_stats.patches_succeeded());
buf_dict->SetInteger("patches_failed", buf_stats.patches_failed());
buf_dict->SetInteger("readaheads_succeeded",
buf_stats.readaheads_succeeded());
buf_dict->SetInteger("readaheads_failed", buf_stats.readaheads_failed());
buf_dict->SetInteger("abi_violations", buf_stats.abi_violations());
buf_list->GetList().push_back(std::move(buf_value));
}
dict->SetList("buffer_stats", std::move(buf_list));
return dict;
}
} // namespace
void AppendProtoDictAsJSON(std::string* out,
const perfetto::protos::ChromeTracedValue& dict) {
out->append("{");
DCHECK_EQ(dict.dict_keys_size(), dict.dict_values_size());
for (int i = 0; i < dict.dict_keys_size(); ++i) {
if (i != 0) {
out->append(",");
}
base::EscapeJSONString(dict.dict_keys(i), true, out);
out->append(":");
AppendProtoValueAsJSON(out, dict.dict_values(i));
}
out->append("}");
}
JSONTraceExporter::JSONTraceExporter(OnTraceEventJSONCallback callback)
: json_callback_(callback),
metadata_(std::make_unique<base::DictionaryValue>()) {
DCHECK(json_callback_);
}
JSONTraceExporter::~JSONTraceExporter() = default;
void JSONTraceExporter::OnTraceData(std::vector<perfetto::TracePacket> packets,
bool has_more) {
DCHECK(json_callback_);
DCHECK(!packets.empty() || !has_more);
// Since we write each event before checking the limit, we'll
// always go slightly over and hence we reserve some extra space
// to avoid most reallocs.
const size_t kReserveCapacity = kTraceEventBufferSizeInBytes * 5 / 4;
std::string out;
out.reserve(kReserveCapacity);
if (!has_output_json_preamble_) {
out = "{\"traceEvents\":[";
has_output_json_preamble_ = true;
}
for (auto& encoded_packet : packets) {
perfetto::protos::ChromeTracePacket packet;
bool decoded = encoded_packet.Decode(&packet);
DCHECK(decoded);
if (packet.has_trace_stats()) {
metadata_->SetDictionary("perfetto_trace_stats",
ConvertTraceStatsToDict(packet.trace_stats()));
continue;
}
if (!packet.has_chrome_events()) {
continue;
}
auto& bundle = packet.chrome_events();
std::unordered_map<int, std::string> string_table;
for (auto& string_table_entry : bundle.string_table()) {
string_table[string_table_entry.index()] = string_table_entry.value();
}
for (auto& event : bundle.trace_events()) {
if (out.size() > kTraceEventBufferSizeInBytes) {
json_callback_.Run(out, nullptr, true);
out.clear();
}
if (has_output_first_event_) {
out += ",\n";
} else {
has_output_first_event_ = true;
}
OutputJSONFromTraceEventProto(event, &out, string_table);
}
for (auto& metadata : bundle.metadata()) {
if (metadata.has_string_value()) {
metadata_->SetString(metadata.name(), metadata.string_value());
} else if (metadata.has_int_value()) {
metadata_->SetInteger(metadata.name(), metadata.int_value());
} else if (metadata.has_bool_value()) {
metadata_->SetBoolean(metadata.name(), metadata.bool_value());
} else if (metadata.has_json_value()) {
std::unique_ptr<base::Value> value(
base::JSONReader::Read(metadata.json_value()));
metadata_->Set(metadata.name(), std::move(value));
} else {
NOTREACHED();
}
}
for (auto& legacy_ftrace_output : bundle.legacy_ftrace_output()) {
legacy_system_ftrace_output_ += legacy_ftrace_output;
}
for (auto& legacy_json_trace : bundle.legacy_json_trace()) {
// Tracing agents should only add this field when there is some data.
DCHECK(!legacy_json_trace.data().empty());
switch (legacy_json_trace.type()) {
case perfetto::protos::ChromeLegacyJsonTrace::USER_TRACE:
if (has_output_first_event_) {
out += ",\n";
} else {
has_output_first_event_ = true;
}
out += legacy_json_trace.data();
break;
case perfetto::protos::ChromeLegacyJsonTrace::SYSTEM_TRACE:
if (legacy_system_trace_events_.empty()) {
legacy_system_trace_events_ = "{";
} else {
legacy_system_trace_events_ += ",";
}
legacy_system_trace_events_ += legacy_json_trace.data();
break;
default:
NOTREACHED();
}
}
}
if (!has_more) {
out += "]";
if (!legacy_system_ftrace_output_.empty() ||
!legacy_system_trace_events_.empty()) {
// Should only have system events (e.g. ETW) or system ftrace output.
DCHECK(legacy_system_ftrace_output_.empty() ||
legacy_system_trace_events_.empty());
out += ",\"systemTraceEvents\":";
if (!legacy_system_ftrace_output_.empty()) {
std::string escaped;
base::EscapeJSONString(legacy_system_ftrace_output_,
true /* put_in_quotes */, &escaped);
out += escaped;
} else {
out += legacy_system_trace_events_ + "}";
}
}
if (!metadata_->empty()) {
out += ",\"metadata\":";
std::string json_value;
base::JSONWriter::Write(*metadata_, &json_value);
out += json_value;
}
out += "}";
}
json_callback_.Run(out, metadata_.get(), has_more);
}
} // namespace tracing
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
c0c3520ee991609e81698abe1dbb0498abf204da | b9c61c27a363ac866ac2d9d6a085e7e2db29f5db | /src/Utils/Utils/Geometry/ElementData.cpp | 5507b8260274b5e16fd7f97a4e6a28caf773b2ca | [
"BSD-3-Clause"
] | permissive | ehermes/utilities | e2d6eb8221e0a992701cc42bd719cb9f4d12e372 | 052452fcc3a4f7cc81740086d837c5d03652c030 | refs/heads/master | 2020-06-04T10:20:30.232921 | 2019-06-12T12:36:36 | 2019-06-12T12:36:36 | 191,976,830 | 0 | 0 | BSD-3-Clause | 2019-06-14T16:44:19 | 2019-06-14T16:44:19 | null | UTF-8 | C++ | false | false | 9,840 | cpp | /**
* @file ElementData.cpp
* @copyright This code is licensed under the 3-clause BSD license.\n
* Copyright ETH Zurich, Laboratory for Physical Chemistry, Reiher Group.\n
* See LICENSE.txt for details.
*/
#include "Utils/Geometry/ElementData.h"
#include "Utils/Geometry/ElementInfo.h"
namespace Scine {
namespace Utils {
namespace Constants {
std::unique_ptr<ElementDataSingleton> ElementDataSingleton::d_instance = nullptr;
ElementDataSingleton::ElementDataSingleton() {
init_data();
}
const ElementDataSingleton::ElementData& ElementDataSingleton::operator[](const ElementType& type) const {
return d_container.at(type);
}
const ElementDataSingleton::ElementData& ElementDataSingleton::operator[](const std::string& symbol) const {
auto type = ElementInfo::elementTypeForSymbol(symbol);
return d_container.at(type);
}
const ElementDataSingleton& ElementDataSingleton::instance() {
if (!d_instance)
d_instance = std::unique_ptr<ElementDataSingleton>(new ElementDataSingleton());
return *d_instance;
}
void ElementDataSingleton::init_data() {
// clang-format off
d_container.emplace(ElementType::H, ElementData("H", 1, 1.0079, 109));
d_container.emplace(ElementType::He, ElementData("He", 2, 4.0026, 140));
d_container.emplace(ElementType::Li, ElementData("Li", 3, 6.941, 182));
d_container.emplace(ElementType::Be, ElementData("Be", 4, 9.0122, 153));
d_container.emplace(ElementType::B, ElementData("B", 5, 10.811, 192));
d_container.emplace(ElementType::C, ElementData("C", 6, 12.011, 170));
d_container.emplace(ElementType::N, ElementData("N", 7, 14.007, 155));
d_container.emplace(ElementType::O, ElementData("O", 8, 15.999, 152));
d_container.emplace(ElementType::F, ElementData("F", 9, 18.988, 147));
d_container.emplace(ElementType::Ne, ElementData("Ne", 10, 20.180, 154));
d_container.emplace(ElementType::Na, ElementData("Na", 11, 22.990, 227));
d_container.emplace(ElementType::Mg, ElementData("Mg", 12, 24.305, 173));
d_container.emplace(ElementType::Al, ElementData("Al", 13, 26.982, 184));
d_container.emplace(ElementType::Si, ElementData("Si", 14, 28.086, 210));
d_container.emplace(ElementType::P, ElementData("P", 15, 30.974, 180));
d_container.emplace(ElementType::S, ElementData("S", 16, 32.065, 180));
d_container.emplace(ElementType::Cl, ElementData("Cl", 17, 35.453, 175));
d_container.emplace(ElementType::Ar, ElementData("Ar", 18, 39.948, 188));
d_container.emplace(ElementType::K, ElementData("K", 19, 39.098, 275));
d_container.emplace(ElementType::Ca, ElementData("Ca", 20, 40.078, 231));
d_container.emplace(ElementType::Sc, ElementData("Sc", 21, 44.956, 215));
d_container.emplace(ElementType::Ti, ElementData("Ti", 22, 47.867, 211));
d_container.emplace(ElementType::V, ElementData("V", 23, 50.942, 207));
d_container.emplace(ElementType::Cr, ElementData("Cr", 24, 51.996, 206));
d_container.emplace(ElementType::Mn, ElementData("Mn", 25, 54.938, 205));
d_container.emplace(ElementType::Fe, ElementData("Fe", 26, 55.938, 204));
d_container.emplace(ElementType::Co, ElementData("Co", 27, 58.933, 200));
d_container.emplace(ElementType::Ni, ElementData("Ni", 28, 58.693, 197));
d_container.emplace(ElementType::Cu, ElementData("Cu", 29, 63.546, 196));
d_container.emplace(ElementType::Zn, ElementData("Zn", 30, 65.38, 201));
d_container.emplace(ElementType::Ga, ElementData("Ga", 31, 69.723, 187));
d_container.emplace(ElementType::Ge, ElementData("Ge", 32, 72.64, 211));
d_container.emplace(ElementType::As, ElementData("As", 33, 74.922, 185));
d_container.emplace(ElementType::Se, ElementData("Se", 34, 78.96, 190));
d_container.emplace(ElementType::Br, ElementData("Br", 35, 79.904, 185));
d_container.emplace(ElementType::Kr, ElementData("Kr", 36, 83.798, 202));
d_container.emplace(ElementType::Rb, ElementData("Rb", 37, 83.468, 303));
d_container.emplace(ElementType::Sr, ElementData("Sr", 38, 87.62, 249));
d_container.emplace(ElementType::Y, ElementData("Y", 39, 88.906, 232));
d_container.emplace(ElementType::Zr, ElementData("Zr", 40, 91.224, 223));
d_container.emplace(ElementType::Nb, ElementData("Nb", 41, 92.906, 218));
d_container.emplace(ElementType::Mo, ElementData("Mo", 42, 95.96, 217));
d_container.emplace(ElementType::Tc, ElementData("Tc", 43, 98.91, 216));
d_container.emplace(ElementType::Ru, ElementData("Ru", 44, 101.07, 213));
d_container.emplace(ElementType::Rh, ElementData("Rh", 45, 102.91, 210));
d_container.emplace(ElementType::Pd, ElementData("Pd", 46, 106.42, 210));
d_container.emplace(ElementType::Ag, ElementData("Ag", 47, 107.87, 211));
d_container.emplace(ElementType::Cd, ElementData("Cd", 48, 112.41, 218));
d_container.emplace(ElementType::In, ElementData("In", 49, 114.82, 193));
d_container.emplace(ElementType::Sn, ElementData("Sn", 50, 118.71, 217));
d_container.emplace(ElementType::Sb, ElementData("Sb", 51, 121.76, 206));
d_container.emplace(ElementType::Te, ElementData("Te", 52, 127.60, 206));
d_container.emplace(ElementType::I, ElementData("I", 53, 126.90, 198));
d_container.emplace(ElementType::Xe, ElementData("Xe", 54, 131.29, 216));
d_container.emplace(ElementType::Cs, ElementData("Cs", 55, 132.91, 343));
d_container.emplace(ElementType::Ba, ElementData("Ba", 56, 137.33, 268));
d_container.emplace(ElementType::La, ElementData("La", 57, 138.91, 243));
d_container.emplace(ElementType::Ce, ElementData("Ce", 58, 140.12, 242));
d_container.emplace(ElementType::Pr, ElementData("Pr", 59, 140.91, 240));
d_container.emplace(ElementType::Nd, ElementData("Nd", 60, 144.24, 239));
d_container.emplace(ElementType::Pm, ElementData("Pm", 61, 146.90, 238));
d_container.emplace(ElementType::Sm, ElementData("Sm", 62, 150.36, 236));
d_container.emplace(ElementType::Eu, ElementData("Eu", 63, 151.96, 235));
d_container.emplace(ElementType::Gd, ElementData("Gd", 64, 157.25, 234));
d_container.emplace(ElementType::Tb, ElementData("Tb", 65, 158.93, 233));
d_container.emplace(ElementType::Dy, ElementData("Dy", 66, 162.50, 231));
d_container.emplace(ElementType::Ho, ElementData("Ho", 67, 164.93, 230));
d_container.emplace(ElementType::Er, ElementData("Er", 68, 167.26, 229));
d_container.emplace(ElementType::Tm, ElementData("Tm", 69, 168.93, 227));
d_container.emplace(ElementType::Yb, ElementData("Yb", 70, 173.05, 226));
d_container.emplace(ElementType::Lu, ElementData("Lu", 71, 174.97, 224));
d_container.emplace(ElementType::Hf, ElementData("Hf", 72, 178.49, 223));
d_container.emplace(ElementType::Ta, ElementData("Ta", 73, 180.95, 222));
d_container.emplace(ElementType::W, ElementData("W", 74, 183.84, 218));
d_container.emplace(ElementType::Re, ElementData("Re", 75, 186.21, 216));
d_container.emplace(ElementType::Os, ElementData("Os", 76, 190.23, 216));
d_container.emplace(ElementType::Ir, ElementData("Ir", 77, 192.22, 213));
d_container.emplace(ElementType::Pt, ElementData("Pt", 78, 195.08, 213));
d_container.emplace(ElementType::Au, ElementData("Au", 79, 196.97, 214));
d_container.emplace(ElementType::Hg, ElementData("Hg", 80, 200.59, 223));
d_container.emplace(ElementType::Tl, ElementData("Tl", 81, 204.38, 196));
d_container.emplace(ElementType::Pb, ElementData("Pb", 82, 207.2, 202));
d_container.emplace(ElementType::Bi, ElementData("Bi", 83, 208.98, 207));
d_container.emplace(ElementType::Po, ElementData("Po", 84, 209.98, 197));
d_container.emplace(ElementType::At, ElementData("At", 85, 210, 202));
d_container.emplace(ElementType::Rn, ElementData("Rn", 86, 222, 220));
d_container.emplace(ElementType::Fr, ElementData("Fr", 87, 223, 348));
d_container.emplace(ElementType::Ra, ElementData("Ra", 88, 226.03, 283));
d_container.emplace(ElementType::Ac, ElementData("Ac", 89, 227, 247));
d_container.emplace(ElementType::Th, ElementData("Th", 90, 232.04, 245));
d_container.emplace(ElementType::Pa, ElementData("Pa", 91, 231.04, 243));
d_container.emplace(ElementType::U, ElementData("U", 92, 238.03, 241));
d_container.emplace(ElementType::Np, ElementData("Np", 93, 237.05, 239));
d_container.emplace(ElementType::Pu, ElementData("Pu", 94, 244.10, 243));
d_container.emplace(ElementType::Am, ElementData("Am", 95, 243.10, 244));
d_container.emplace(ElementType::Cm, ElementData("Cm", 96, 247.10, 245));
d_container.emplace(ElementType::Bk, ElementData("Bk", 97, 247.10, 244));
d_container.emplace(ElementType::Cf, ElementData("Cf", 98, 251.10, 245));
d_container.emplace(ElementType::Es, ElementData("Es", 99, 254.10, 245));
d_container.emplace(ElementType::Fm, ElementData("Fm", 100, 257.10, 245));
d_container.emplace(ElementType::Md, ElementData("Md", 101, 258, 246));
d_container.emplace(ElementType::No, ElementData("No", 102, 259, 246));
d_container.emplace(ElementType::Lr, ElementData("Lr", 103, 262, 246));
d_container.emplace(ElementType::Rf, ElementData("Rf", 104, 261 ));
d_container.emplace(ElementType::Db, ElementData("Db", 105, 262 ));
d_container.emplace(ElementType::Sg, ElementData("Sg", 106, 266 ));
d_container.emplace(ElementType::Bh, ElementData("Bh", 107, 264 ));
d_container.emplace(ElementType::Hs, ElementData("Hs", 108, 277 ));
d_container.emplace(ElementType::Mt, ElementData("Mt", 109, 268 ));
d_container.emplace(ElementType::Ds, ElementData("Ds", 110, 281 ));
d_container.emplace(ElementType::Rg, ElementData("Rg", 111, 280 ));
d_container.emplace(ElementType::Cn, ElementData("Cn", 112, 285 ));
// clang-format on
}
} /* namespace Constants */
} /* namespace Utils */
} /* namespace Scine */
| [
"scine@phys.chem.ethz.ch"
] | scine@phys.chem.ethz.ch |
4769c944d1fabab49fab952cde5a73be8b2deb16 | de1a9c46f8fea35c4c89bcbb18a3e808f003aa9d | /include/owlcpp/ns_id.hpp | fe481da2f5acc691b075583a35fb5c7dbeedd36d | [
"LicenseRef-scancode-unknown-license-reference",
"BSL-1.0"
] | permissive | idscan/owl-cpp | 080d0d325cc96f0a0ebb220c23d7a570b0a9a8e4 | 3d14df934671e5a8548d2a870340890a537f4b1f | refs/heads/idscan-hunter | 2021-08-15T13:25:39.464931 | 2021-08-04T15:59:23 | 2021-08-04T15:59:23 | 121,740,704 | 0 | 1 | null | 2021-08-04T15:59:24 | 2018-02-16T10:52:56 | C++ | UTF-8 | C++ | false | false | 928 | hpp | /** @file "/owlcpp/include/owlcpp/ns_id.hpp"
part of owlcpp project.
@n Distributed under the Boost Software License, Version 1.0; see doc/license.txt.
@n Copyright Mikhail K Levin 2010
*******************************************************************************/
#ifndef NS_ID_HPP_
#define NS_ID_HPP_
#include <iosfwd>
#include "owlcpp/detail/object_id_base.hpp"
namespace owlcpp{
/** Namespace identifier
*******************************************************************************/
class Ns_id : public detail::Base_id<Ns_id> {
public:
Ns_id() : base(0) {}
explicit Ns_id(const unsigned x) : base(x) {}
};
/**
*******************************************************************************/
template<class ChT, class Tr> inline std::basic_ostream<ChT,Tr>& operator<<(
std::basic_ostream<ChT,Tr>& os,
Ns_id const& id
) {
return os << "Ns" << id();
}
}//namespace owlcpp
#endif /* NS_ID_HPP_ */
| [
"mlevin@svarnetics.org"
] | mlevin@svarnetics.org |
1d63ea4ec08c12b626b745ea4565d12a834226b5 | ee023aca334b169a63d87faaab5229408cd5e341 | /format/V12/formatcasttest.cpp | 4d3de82bc57d8aca7e2537ec6e26279c41cf37d9 | [] | no_license | jrtomps/nscldaq-format | 33b1b3bee0d403565137159b868c258cd4b24a4f | 0b283ea420cedbf1464b03dd2682c7b49f428428 | refs/heads/master | 2021-01-19T12:58:56.375891 | 2017-04-05T17:39:14 | 2017-04-05T17:39:14 | 82,353,480 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,951 | cpp |
// Template for a test suite.
#include <cppunit/extensions/HelperMacros.h>
#include <cppunit/Asserter.h>
#include <string>
#include "Asserts.h"
#include "V12/DataFormat.h"
#include "V12/format_cast.h"
#include "V12/CRawRingItem.h"
#include "V12/CDataFormatItem.h"
#include "ByteBuffer.h"
#include "ContainerDeserializer.h"
#include <iostream>
#include <sstream>
// Tests for glom parameter ring item class:
using namespace DAQ;
using namespace DAQ::V12;
class format_castTests : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(format_castTests);
CPPUNIT_TEST(toRawRingItem_0);
CPPUNIT_TEST(fromRawRingItem_0);
CPPUNIT_TEST_SUITE_END();
private:
public:
void setUp() {
}
void tearDown() {
}
protected:
void toRawRingItem_0() {
V12::CDataFormatItem item;
auto rawItem = V12::format_cast<V12::CRawRingItem>(item);
uint16_t major, minor;
Buffer::ContainerDeserializer<Buffer::ByteBuffer> stream(rawItem.getBody());
stream >> major >> minor;
EQMSG("size", uint32_t(24), rawItem.size());
EQMSG("type", RING_FORMAT, rawItem.type());
EQMSG("evt tstamp", NULL_TIMESTAMP, rawItem.getEventTimestamp());
EQMSG("source id", uint32_t(0), rawItem.getSourceId());
EQMSG("major", uint16_t(12), major);
EQMSG("minor", uint16_t(0), minor);
}
void fromRawRingItem_0()
{
V12::CRawRingItem rawItem;
rawItem.getBody() << uint16_t(12) << uint16_t(0);
auto item = V12::format_cast<V12::CDataFormatItem>(rawItem);
EQMSG("size", uint32_t(24), item.size());
EQMSG("type", RING_FORMAT, item.type());
EQMSG("evt tstamp", NULL_TIMESTAMP, item.getEventTimestamp());
EQMSG("source id", uint32_t(0), item.getSourceId());
EQMSG("major", uint16_t(12), item.getMajor());
EQMSG("minor", uint16_t(0), item.getMinor());
}
};
CPPUNIT_TEST_SUITE_REGISTRATION(format_castTests);
// Test parameters if not building:
| [
"tompkins@nscl.msu.edu"
] | tompkins@nscl.msu.edu |
b5b1eae6c5031004c91af24008db65ca1023d75a | 5cf5223da2bf49af7f5a8ecde4d1cb31536f5ce7 | /extras/apps/mason2/methylation_levels.h | be01c29ad777bc27598f029018eae59cfa93185b | [
"BSD-3-Clause"
] | permissive | jwillis0720/seqan | e579f8419cec7f330eb1fe29838c5c098ee57240 | 36b300b8c4c42bbfc03edd3220fa299961d517be | refs/heads/master | 2020-12-02T15:06:46.899846 | 2015-01-10T08:59:05 | 2015-01-10T08:59:05 | 27,658,559 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,655 | h | // ==========================================================================
// Mason - A Read Simulator
// ==========================================================================
// Copyright (c) 2006-2013, Knut Reinert, FU Berlin
// 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 Knut Reinert or the FU Berlin 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 KNUT REINERT OR THE FU BERLIN 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.
//
// ==========================================================================
// Author: Manuel Holtgrewe <manuel.holtgrewe@fu-berlin.de>
// ==========================================================================
#ifndef EXTRAS_APPS_MASON2_METHYLATION_LEVELS_H_
#define EXTRAS_APPS_MASON2_METHYLATION_LEVELS_H_
#include <seqan/index.h> // for Shape<>
#include <seqan/sequence.h>
#include <seqan/sequence_journaled.h> // for the journal
#include "mason_types.h"
#include "mason_options.h"
// ============================================================================
// Forwards
// ============================================================================
typedef seqan::Rng<> TRng;
// ============================================================================
// Tags, Classes, Enums
// ============================================================================
// --------------------------------------------------------------------------
// Class MethylationLevels
// --------------------------------------------------------------------------
// Stores methylation levels separately for forward and reverse strand.
struct MethylationLevels
{
// Forward and reverse levels, encoded as round(level / 0.125) + 33.
seqan::CharString forward, reverse;
void resize(unsigned len)
{
seqan::resize(forward, len, '!');
seqan::resize(reverse, len, '!');
}
void clear()
{
seqan::clear(forward);
seqan::clear(reverse);
}
// Translate character in forward/reverse to level (0..80).
inline char charToLevel(char c) const
{
if (c < '>') // '>' cannot be used as value
return c - 33;
else
return c - 34;
}
// Translate level (0..80) to character in forward/reverse.
inline char levelToChar(char c) const
{
if (c + '!' < '>')
return c + 33;
else
return c + 34;
}
// Returns methylation level for forward strand at position i.
inline float levelF(unsigned i) const
{
return (charToLevel(forward[i]) * 0.0125);
}
// Sets methylation level for forward strand at position i.
inline void setLevelF(unsigned i, float level)
{
SEQAN_ASSERT_GEQ(level, 0.0);
SEQAN_ASSERT_LEQ(level, 1.0);
// std::cerr << "forward[i] = " << levelToChar(round(level / 0.0125)) << " ~ " << (level / 0.0125) << " ~ " << level << "\n";
char c = levelToChar(static_cast<char>(round(level / 0.0125)));
SEQAN_ASSERT_NEQ((int)c, (int)'>');
forward[i] = std::max(forward[i], c);
}
// Returns methylation level for reverse strand at position i.
inline float levelR(unsigned i) const
{
return (charToLevel(reverse[i]) * 0.0125);
}
// Sets methylation level for reverse strand at position i if level is larger than current.
inline void setLevelR(unsigned i, float level)
{
SEQAN_ASSERT_GEQ(level, 0.0);
SEQAN_ASSERT_LEQ(level, 1.0);
// std::cerr << "reverse[" << i << "] = " << levelToChar(round(level / 0.0125)) << " ~ " << (level / 0.0125) << " ~ " << level << "\n";
char c = levelToChar(static_cast<char>(round(level / 0.0125)));
SEQAN_ASSERT_NEQ((int)c, (int)'>');
reverse[i] = std::max(reverse[i], c);
}
};
inline
void swap(MethylationLevels & lhs, MethylationLevels & rhs)
{
swap(lhs.forward, rhs.forward);
swap(lhs.reverse, rhs.reverse);
}
// --------------------------------------------------------------------------
// Class MethylationLevelSimulator
// --------------------------------------------------------------------------
// Simulate methylation levels for a Dna sequence/contig on forward and reverse strand.
class MethylationLevelSimulator
{
public:
// Options for the mu/sigma values.
MethylationLevelSimulatorOptions const & options;
// Random number generator to use.
TRng & rng;
// Beta probability density functions for level generation.
seqan::Pdf<seqan::Beta> pdfCG, pdfCHG, pdfCHH;
MethylationLevelSimulator(TRng & rng, MethylationLevelSimulatorOptions const & options) :
options(options), rng(rng),
pdfCG(options.methMuCG, options.methSigmaCG, seqan::MeanStdDev()),
pdfCHG(options.methMuCHG, options.methSigmaCHG, seqan::MeanStdDev()),
pdfCHH(options.methMuCHH, options.methSigmaCHH, seqan::MeanStdDev())
{}
// Simulate methylation levels for the sequence in contig. The results are stored in levels.
void run(MethylationLevels & levels, seqan::Dna5String const & contig)
{
levels.resize(length(contig));
typedef seqan::Iterator<seqan::Dna5String const>::Type TContigIter;
TContigIter it = begin(contig, seqan::Standard());
TContigIter itEnd = end(contig, seqan::Standard()) - 3;
// We will go over the contig with hashes to search for patterns efficiently.
seqan::Shape<seqan::Dna5> shape2, shape3;
if (levels.forward[0] != '!') SEQAN_ASSERT_EQ_MSG(contig[0], 'C', "pos = %d", 0);
if (levels.reverse[0] != '!') SEQAN_ASSERT_EQ_MSG(contig[0], 'G', "pos = %d", 0);
if (length(contig) >= 2u)
{
resize(shape2, 2);
hash(shape2, it);
handleTwoMer(levels, 0, value(shape2));
if (levels.forward[1] != '!') SEQAN_ASSERT_EQ_MSG(contig[1], 'C', "pos = %d", 1);
if (levels.reverse[1] != '!') SEQAN_ASSERT_EQ_MSG(contig[1], 'G', "pos = %d", 1);
}
if (length(contig) >= 3u)
{
resize(shape3, 3);
hash(shape3, it);
handleThreeMer(levels, 0, value(shape3));
if (levels.forward[2] != '!') SEQAN_ASSERT_EQ_MSG(contig[2], 'C', "pos = %d", 2);
if (levels.reverse[2] != '!') SEQAN_ASSERT_EQ_MSG(contig[2], 'G', "pos = %d", 2);
}
++it;
unsigned pos = 1;
for (; (pos + 3 < length(contig)) && (it != itEnd); ++it, ++pos)
{
hashNext(shape2, it);
hashNext(shape3, it);
handleTwoMer(levels, pos, value(shape2));
handleThreeMer(levels, pos, value(shape3));
if (levels.forward[pos] != '!') SEQAN_ASSERT_EQ_MSG(contig[pos], 'C', "pos = %u", pos);
if (levels.reverse[pos] != '!') SEQAN_ASSERT_EQ_MSG(contig[pos], 'G', "pos = %u", pos);
}
if (pos + 1 < length(contig))
{
hashNext(shape2, it++);
handleTwoMer(levels, pos++, value(shape2));
}
}
// Handle 3mer, forward case.
void handleThreeMer(MethylationLevels & levels, unsigned pos, unsigned hashValue)
{
// seqan::Dna5String dbg, dbg2;
// unhash(dbg, hashValue, 3);
// dbg2 = dbg;
// reverse(dbg2);
switch (hashValue)
{
case 27: // CAG
case 42: // CTG
// std::cerr << "CHG fw \t" << dbg << "\t" << dbg2 << "\t" << pos << "\n";
levels.setLevelF(pos, pickRandomNumber(rng, pdfCHG));
levels.setLevelR(pos + 2, pickRandomNumber(rng, pdfCHG));
break;
case 32: // CCG
levels.setLevelF(pos, pickRandomNumber(rng, pdfCHG));
levels.setLevelR(pos + 2, pickRandomNumber(rng, pdfCG));
break;
case 25: // CAA
case 26: // CAC
case 28: // CAT
case 30: // CCA
case 31: // CCC
case 33: // CCT
case 40: // CTA
case 41: // CTC
case 43: // CTT
// std::cerr << "CHH \t" << dbg << "\t" << dbg2 << "\t" << pos << "\n";
levels.setLevelF(pos, pickRandomNumber(rng, pdfCHH));
break;
case 2: // AAG
case 12: // AGG
case 17: // ATG
case 52: // GAG
case 62: // GGG
case 67: // GTG
case 77: // TAG
case 87: // TGG
case 92: // TTG
levels.setLevelR(pos + 2, pickRandomNumber(rng, pdfCHH));
break;
default:
// nop
break;
}
}
// Handle 2mer.
void handleTwoMer(MethylationLevels & levels, unsigned pos, unsigned hashValue)
{
if (hashValue == 7) // CpG forward (symmetric, also reverse)
{
// seqan::Dna5String dbg;
// unhash(dbg, hashValue, 2);
// std::cerr << "CpG \t" << dbg << "\n";
levels.setLevelF(pos, pickRandomNumber(rng, pdfCG));
levels.setLevelR(pos + 1, pickRandomNumber(rng, pdfCG));
}
}
};
// ============================================================================
// Metafunctions
// ============================================================================
// ============================================================================
// Functions
// ============================================================================
// ----------------------------------------------------------------------------
// Function VariantMaterializer::_fixVariationLevels()
// ----------------------------------------------------------------------------
// Fix variation levels on contig given the points (second == true -> SNP, second == false -> breakpoint).
void fixVariationLevels(MethylationLevels & levels,
TRng & rng,
seqan::Dna5String const & contig,
seqan::String<std::pair<int, bool> > const & varPoints,
MethylationLevelSimulatorOptions const & options);
#endif // #ifndef EXTRAS_APPS_MASON2_METHYLATION_LEVELS_H_
| [
"holtgrew@e6417c60-b987-48fd-844e-b20f0fcc1017"
] | holtgrew@e6417c60-b987-48fd-844e-b20f0fcc1017 |
e7d1e761466210ae633b7ff24380403613b8dfaa | 84db845cc485c91e6dbc44e4944a85d27518c9a8 | /Templates/hungary_mutiMatch.cpp | d5280030d57fcd043731d724ae12b52b54feda2f | [] | no_license | sunyinkai/ACM_ICPC | c13398c6963f0267db282e71d11baaf7ff619c71 | 8e54240df29b4a722efd27b5866384ba84f859a4 | refs/heads/master | 2021-07-07T07:39:36.553203 | 2020-07-26T06:50:54 | 2020-07-26T06:50:54 | 158,057,635 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,419 | cpp | #include<cstdio>
#include <cstring>
const int MAXN=1e5+7;
const int MAXM=12;
using namespace std;
int map[MAXN][MAXM];
int vis[MAXM],link[MAXM][MAXN];
int num[MAXM],cap[MAXM];
//num:已经匹配了的数量,cap:右边的容量
// map:left->right
//link right->left
//O(VE)
//下标从1开始,
int n,m;
int dfs(int v){
for(int i=1;i<=m;++i){
if(map[v][i]&&!vis[i]){
vis[i]=1;
if(num[i]<cap[i]){
link[i][++num[i]]=v;
return 1;
}
for(int j=1;j<=num[i];++j){
if(dfs(link[i][j])){
link[i][j]=v;
return 1;
}
}
}
}
return 0;
}
int main(){
while(~scanf("%d%d",&n,&m)){
for(int i=1;i<=n;++i)//n->m
for(int j=1;j<=m;++j)
scanf("%d",&map[i][j]);
//下标从1开始
for(int i=1;i<=m;++i)
scanf("%d",&cap[i]);
memset(num,0,sizeof(num));
int flag=0;
int res;
for(int i=1;i<=n;++i){
memset(vis,0,sizeof(vis));
res+=dfs(i);//寻找增广路
/*if(!dfs(i)){
flag=1;//对于这个题，要求全部匹配,如果找不到直接退出
break;
}*/
}
if(flag)printf("NO\n");
else printf("YES\n");
}
return 0;
}
| [
"1091491336@qq.com"
] | 1091491336@qq.com |
219cd0867b53c770dcf4fe5b17426fc536519a9d | 63aae97c48b052eac1fdedd1871ba540f98593f2 | /소스50.cpp | f1c9e02af2fe424de6578ce647767af8e6b83abb | [] | no_license | hunputer/algorithm | 2f336aff0e9907b43b0a22abc704d6383081e7e8 | 7af2295e8f105a85e5f188a27866a5aab842aae2 | refs/heads/master | 2020-06-16T16:38:28.202555 | 2019-09-08T09:39:48 | 2019-09-08T09:39:48 | 195,638,484 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 400 | cpp | /*#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i].first;
p[i].second = (i+1);
}
sort(p.begin(), p.end());
int ans = 0;
for (int i = 0; i < n; i++) {
if ((p[i].second - (i+1)) > ans) {
ans = p[i].second - (i+1);
}
}
cout << ans+1 << endl;
}*/ | [
"wlgns3855@gemail.com"
] | wlgns3855@gemail.com |
d2fb6914ccc30cdd44fa8cfb4fe06723e734879e | 7ddf7754cf43f83b3e6f7616b3917ce234eb3354 | /balanced_binary_tree_110.cpp | 5ed546a16c6d645a652c3ed63861d143bf339af7 | [] | no_license | klasdfiz/leetcode | df7674a082e8dd2a3e109fc67ac7237846bc5aaa | 410fae068166e5b92b42c5f7ee1874e438c3a1ac | refs/heads/master | 2020-05-20T17:56:13.047105 | 2016-06-19T14:05:01 | 2016-06-19T14:05:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 987 | cpp | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int abs(int a, int b)
{
int res = a - b;
if (res < 0)
res = -res;
return res;
}
int treeHeight(TreeNode* root)
{
if (!root)
return 0;
return (max(treeHeight(root->left), treeHeight(root->right)) + 1);
}
bool isBalanced(TreeNode* root) {
if (!root)
return true;
if (abs(treeHeight(root->left), treeHeight(root->right)) > 1)
return false;
if (!isBalanced(root->left) || !isBalanced(root->right))
return false;
return true;
}
};
//the previous solution can be conclude below
int depth(TreeNode* root) {
return root?max(depth(root->left),depth(root->right))+1:0;
}
bool isBalanced(TreeNode* root) {
return root?abs(depth(root->left)-depth(root->right))<=1&&isBalanced(root->left)&&isBalanced(root->right):true;
} | [
"zkjxlh@163.com"
] | zkjxlh@163.com |
e6797efdad97c444273883f6578037e52481154a | 0ab9e007c7dd11420e671785f584031f47f1504b | /src/ballistica/ui/widget/row_widget.h | 583dd81c1d68d7f031a5714c64ebb9b79fcc94c1 | [
"MIT"
] | permissive | Dliwk/ballistica | 7872e1e8d0f3a2d92c9a6c211acade3961cbafdd | 73b18e449838c19c87fb86147a253300836cfe89 | refs/heads/master | 2023-07-21T23:28:43.380564 | 2023-01-18T18:40:44 | 2023-01-18T18:40:44 | 254,022,422 | 0 | 0 | MIT | 2020-04-09T12:20:04 | 2020-04-08T07:58:10 | Python | UTF-8 | C++ | false | false | 622 | h | // Released under the MIT License. See LICENSE for details.
#ifndef BALLISTICA_UI_WIDGET_ROW_WIDGET_H_
#define BALLISTICA_UI_WIDGET_ROW_WIDGET_H_
#include <string>
#include "ballistica/ui/widget/container_widget.h"
namespace ballistica {
// Layout widget for organizing widgets in a row
class RowWidget : public ContainerWidget {
public:
RowWidget();
~RowWidget() override;
auto HandleMessage(const WidgetMessage& m) -> bool override;
auto GetWidgetTypeName() -> std::string override;
protected:
void UpdateLayout() override;
};
} // namespace ballistica
#endif // BALLISTICA_UI_WIDGET_ROW_WIDGET_H_
| [
"ericfroemling@gmail.com"
] | ericfroemling@gmail.com |
a1eae356e8ae1c037ce3ccda54ac077fbe4744b0 | 4cf190c8fc97f616162e8ce6ced24e59fca6d47b | /OutOfBoundsException.h | cbfedc5e5b86fdfb55b8653fc9b1575a7ae3f9f6 | [] | no_license | miloszkadziela/simple-matrix-calculator | d7ce6f1081ba37ee8604712a0af9f09d97c23577 | bcfad2d4b46a4d0f9734fb775c44b89bee5ac07a | refs/heads/master | 2020-03-17T11:21:52.643648 | 2018-05-15T17:13:13 | 2018-05-15T17:13:13 | 133,548,727 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 223 | h | #include <ostream>
#include <exception>
class OutOfBoundsException : public std::exception {
std::string msg;
public:
OutOfBoundsException(size_t i);
const char* what() const noexcept override;
};
| [
"miloszkadziela@o2.pl"
] | miloszkadziela@o2.pl |
3333623e13ca4aedb19b98411c6108a31955c248 | 3d6f8232d33c924e94dac543996ac42979a81836 | /Revenge/Revenge/AudioPlayer.h | b6cc4daeb399d6a924b32c6e29d4ffc1f2f73914 | [] | no_license | ddthejj/Revenge | a2150f025c0aedd692e4f2eb6c0cbae121318c00 | 7d2cf04ef9f3197ffd42532d605846dc8c2bf346 | refs/heads/master | 2023-08-24T23:13:49.353503 | 2023-08-06T22:25:50 | 2023-08-06T22:25:50 | 124,099,422 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 583 | h | #pragma once
#ifndef _SOUNDCLASS_H_
#define _SOUNDCLASS_H_
// linker
#pragma comment(lib, "dsound.lib")
#pragma comment(lib, "dxguid.lib")
#pragma comment(lib, "winmm.lib")
#include <windows.h>
#include <mmsystem.h>
#include <dsound.h>
#include <stdio.h>
struct Impl_Elements;
class AudioPlayer
{
public:
AudioPlayer();
~AudioPlayer();
bool Init(HWND hWnd);
void Clean();
bool LoadWAVs(const char* filepath);
bool UnloadWAVs();
bool PlayWAV(int index);
private:
int LoadWAV(const char* filepath);
bool UnloadWAV(int index);
Impl_Elements* elements;
};
#endif
| [
"cooleaddento@gmail.com"
] | cooleaddento@gmail.com |
c0664eff38c2d144ea21d23beee42ee4d6175d33 | b7bc30a3c9e386d3c2f63546e91a7a50a0183a44 | /Texture.h | 42e9fc41bb4e0bfda0a2dd9b85d46e94a018ad4c | [] | no_license | RobPiwowarek/GLHammer | 60743316862cba181697e1a0759af0857a9947d4 | 439b460d519b280ced4c72ad1eb5d5f5a43475f3 | refs/heads/master | 2020-12-30T11:52:29.064140 | 2017-05-25T23:24:52 | 2017-05-25T23:24:52 | 91,434,987 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 205 | h | #ifndef TEXTURE
#define TEXTURE
#include <GL/glew.h>
#include <string>
class Texture{
public:
Texture(std::string file);
GLuint getID() { return mTextureID; }
private:
GLuint mTextureID;
};
#endif | [
"robpiwowarek@gmail.com"
] | robpiwowarek@gmail.com |
d81b6715d8026315b5d1493c4220ea8caa1bb5e9 | ab0a8234e443a6aa152b9f7b135a1e2560e9db33 | /Server/CGSF/DatabaseLayer/CppDatabasePool/examples/ExampleSQLSvr.cpp | db3df26d902f85e0e78964fd4b66705fd692f311 | [] | no_license | zetarus/Americano | 71c358d8d12b144c8858983c23d9236f7d0e941b | b62466329cf6f515661ef9fb9b9d2ae90a032a60 | refs/heads/master | 2023-04-08T04:26:29.043048 | 2018-04-19T11:21:14 | 2018-04-19T11:21:14 | 104,159,178 | 9 | 2 | null | 2023-03-23T12:10:51 | 2017-09-20T03:11:44 | C++ | UTF-8 | C++ | false | false | 2,798 | cpp | /* Copyright 2009 Righteous Ninja AKA P.S. Ching*/
#include <iostream>
#include "..\sqlserver\SQLSvrPool.h"
using namespace std;
int main(){
SQLSvrPool* sqlsvrpool = new SQLSvrPool( "localhost", //hostnam
"MyDatabase", //database
"sa", //username
"Admin-123", //password
300000, //keepalive timeout (milliseconds)
"SELECT top 1 name FROM dbo.sysobjects"); //keepalive statement
/*Create a pool that will have 3 cached connections and will swell upto a
total of 5 connections. Returns the number of cached connections or -1 on error
*/
if(sqlsvrpool->CreatePool(3, 5)<=0){
cout<<"Error creating database pool\n";
cout<<sqlsvrpool->GetLastSystemError()<<endl; //If it's asystem error
goto EXAMPLE_END;
}
/*Dispaly the pool information*/
cout<<(*sqlsvrpool);
SQLHANDLE* psqlconnectionhandle;
SQLHANDLE sqlstatementhandle;
/*Test the validity of the pool at anytime - not really required*/
if(!sqlsvrpool->IsPoolValid())
goto EXAMPLE_END;
/*Get a connection from the pool*/
if((psqlconnectionhandle=sqlsvrpool->GetConnectionFromPool())==0){
cout<<"You have reached the maximum amout allowed - 5 in this example\n";
goto EXAMPLE_END;
}
/*Get a statement handle from the connection*/
if(SQL_SUCCESS!=SQLAllocHandle(SQL_HANDLE_STMT, *psqlconnectionhandle, &sqlstatementhandle)){
sqlsvrpool->ShowSQLError(cout, SQL_HANDLE_DBC, *psqlconnectionhandle);
goto EXAMPLE_END;
}
/*Execute the query and display the results. Do not Free the database connection handle.
This will be released via the ReleaseConnectionToPool back to the pool.
*/
if(SQL_SUCCESS!=SQLExecDirect(sqlstatementhandle, (SQLCHAR*)"select * from testtable", SQL_NTS)){
sqlsvrpool->ShowSQLError(cout, SQL_HANDLE_STMT, sqlstatementhandle);
goto EXAMPLE_END;
}
else{
char name[64];
char address[64];
int id;
while(SQLFetch(sqlstatementhandle)==SQL_SUCCESS){
SQLGetData(sqlstatementhandle, 1, SQL_C_ULONG, &id, 0, NULL);
SQLGetData(sqlstatementhandle, 2, SQL_C_CHAR, name, 64, NULL);
SQLGetData(sqlstatementhandle, 3, SQL_C_CHAR, address, 64, NULL);
cout<<id<<" "<<name<<" "<<address<<endl;
}
}
SQLFreeHandle(SQL_HANDLE_STMT, sqlstatementhandle );
/*Dispaly the pool information*/
cout<<(*sqlsvrpool);
/*Release the connection back into the pool*/
sqlsvrpool->ReleaseConnectionToPool(psqlconnectionhandle);
/*Dispaly the pool information*/
cout<<(*sqlsvrpool);
char c;
cout<<"Enter character to exit\n";
cin>>c;
EXAMPLE_END:
/*Destroy the database pool*/
if(sqlsvrpool->DestroyPool()>0){
cout<<"There are still some un-released connections in the pool\n";
}
delete sqlsvrpool;
return 0;
}
| [
"sinyonzzang@gmail.com"
] | sinyonzzang@gmail.com |
f54b38f6605ea4f89696398ba4228e2fa9dedcbf | 17353cfd2c984f2b57ab09dce5b793f34b051f19 | /src/plugProjectNishimuraU/SnakeWholeMgr.cpp | d6d4050038895ed97c46da216328617bbeafa945 | [] | no_license | mxygon/pikmin2 | 573df84b127b27f1c5db6be22680b63fd34565d5 | fa16b706d562d3f276406d8a87e01ad541515737 | refs/heads/main | 2023-09-02T06:56:56.216154 | 2021-11-12T09:34:26 | 2021-11-12T09:34:26 | 427,367,127 | 1 | 0 | null | 2021-11-12T13:19:54 | 2021-11-12T13:19:53 | null | UTF-8 | C++ | false | false | 8,815 | cpp | #include "types.h"
namespace Game {
/*
* --INFO--
* Address: 802CE2DC
* Size: 000050
*/
SnakeWhole::Mgr::Mgr(int, unsigned char)
{
/*
.loc_0x0:
stwu r1, -0x10(r1)
mflr r0
stw r0, 0x14(r1)
stw r31, 0xC(r1)
mr r31, r3
bl -0x19F65C
lis r3, 0x804D
lis r4, 0x8049
addi r5, r3, 0x2358
mr r3, r31
stw r5, 0x0(r31)
addi r5, r5, 0x38
subi r0, r4, 0x47E4
stw r5, 0x4(r31)
stw r0, 0x18(r31)
lwz r31, 0xC(r1)
lwz r0, 0x14(r1)
mtlr r0
addi r1, r1, 0x10
blr
*/
}
/*
* --INFO--
* Address: 802CE32C
* Size: 000048
*/
void SnakeWhole::Mgr::doAlloc()
{
/*
.loc_0x0:
stwu r1, -0x10(r1)
mflr r0
stw r0, 0x14(r1)
stw r31, 0xC(r1)
mr r31, r3
li r3, 0x8A8
bl -0x2AA4A0
mr. r4, r3
beq- .loc_0x2C
bl .loc_0x48
mr r4, r3
.loc_0x2C:
mr r3, r31
bl -0x19EAC0
lwz r0, 0x14(r1)
lwz r31, 0xC(r1)
mtlr r0
addi r1, r1, 0x10
blr
.loc_0x48:
*/
}
/*
* --INFO--
* Address: 802CE374
* Size: 000154
*/
SnakeWhole::Parms::Parms()
{
/*
.loc_0x0:
stwu r1, -0x10(r1)
mflr r0
lis r4, 0x8049
stw r0, 0x14(r1)
stw r31, 0xC(r1)
mr r31, r3
stw r30, 0x8(r1)
subi r30, r4, 0x47F8
bl -0x1C4BF8
lis r3, 0x804D
lis r5, 0x6670
addi r0, r3, 0x2438
addi r4, r31, 0x8A4
stw r0, 0xD8(r31)
li r7, 0
addi r0, r30, 0x30
addi r3, r31, 0x804
stw r4, 0x7F8(r31)
addi r4, r31, 0x7F8
addi r5, r5, 0x3031
addi r6, r30, 0x40
stw r7, 0x7FC(r31)
stw r0, 0x800(r31)
bl 0x145288
lis r3, 0x804B
lis r5, 0x6670
subi r0, r3, 0x5344
lfs f0, -0x1B18(r2)
stw r0, 0x804(r31)
addi r3, r31, 0x82C
lfs f1, -0x1B14(r2)
addi r4, r31, 0x7F8
stfs f0, 0x81C(r31)
addi r5, r5, 0x3131
lfs f0, -0x1B10(r2)
addi r6, r30, 0x4C
stfs f1, 0x824(r31)
stfs f0, 0x828(r31)
bl 0x14524C
lis r3, 0x804B
lis r5, 0x6670
subi r0, r3, 0x5344
lfs f0, -0x1B0C(r2)
stw r0, 0x82C(r31)
addi r3, r31, 0x854
lfs f1, -0x1B14(r2)
addi r4, r31, 0x7F8
stfs f0, 0x844(r31)
addi r5, r5, 0x3132
lfs f0, -0x1B08(r2)
addi r6, r30, 0x5C
stfs f1, 0x84C(r31)
stfs f0, 0x850(r31)
bl 0x145210
lis r3, 0x804B
lis r5, 0x6670
subi r0, r3, 0x5344
lfs f0, -0x1B10(r2)
stw r0, 0x854(r31)
addi r3, r31, 0x87C
lfs f1, -0x1B14(r2)
addi r4, r31, 0x7F8
stfs f0, 0x86C(r31)
addi r5, r5, 0x3231
lfs f0, -0x1B08(r2)
addi r6, r30, 0x6C
stfs f1, 0x874(r31)
stfs f0, 0x878(r31)
bl 0x1451D4
lis r3, 0x804B
lfs f2, -0x1B04(r2)
subi r0, r3, 0x5344
lfs f1, -0x1B14(r2)
stw r0, 0x87C(r31)
mr r3, r31
lfs f0, -0x1B00(r2)
stfs f2, 0x894(r31)
stfs f1, 0x89C(r31)
stfs f0, 0x8A0(r31)
lwz r31, 0xC(r1)
lwz r30, 0x8(r1)
lwz r0, 0x14(r1)
mtlr r0
addi r1, r1, 0x10
blr
*/
}
/*
* --INFO--
* Address: 802CE4C8
* Size: 000060
*/
void SnakeWhole::Mgr::createObj(int)
{
/*
.loc_0x0:
stwu r1, -0x10(r1)
mflr r0
stw r0, 0x14(r1)
stw r31, 0xC(r1)
mr r31, r4
stw r30, 0x8(r1)
mr r30, r3
mulli r3, r31, 0x340
addi r3, r3, 0x10
bl -0x2AA540
lis r4, 0x802D
lis r5, 0x802D
subi r4, r4, 0x1868
mr r7, r31
subi r5, r5, 0x1AD8
li r6, 0x340
bl -0x20CB18
stw r3, 0x44(r30)
lwz r0, 0x14(r1)
lwz r31, 0xC(r1)
lwz r30, 0x8(r1)
mtlr r0
addi r1, r1, 0x10
blr
*/
}
/*
* --INFO--
* Address: 802CE528
* Size: 0000BC
*/
SnakeWhole::Obj::~Obj()
{
/*
.loc_0x0:
stwu r1, -0x10(r1)
mflr r0
stw r0, 0x14(r1)
stw r31, 0xC(r1)
mr. r31, r3
stw r30, 0x8(r1)
mr r30, r4
beq- .loc_0xA0
lis r3, 0x804D
addi r0, r31, 0x330
addi r4, r3, 0x2478
stw r4, 0x0(r31)
addi r3, r4, 0x1B0
addi r4, r4, 0x2FC
stw r3, 0x178(r31)
lwz r3, 0x17C(r31)
stw r4, 0x0(r3)
lwz r3, 0x17C(r31)
sub r0, r0, r3
stw r0, 0xC(r3)
beq- .loc_0x90
lis r3, 0x804B
addi r0, r31, 0x2BC
subi r4, r3, 0x5CDC
addi r3, r31, 0x290
stw r4, 0x0(r31)
addi r5, r4, 0x1B0
addi r6, r4, 0x2F8
li r4, -0x1
stw r5, 0x178(r31)
lwz r5, 0x17C(r31)
stw r6, 0x0(r5)
lwz r5, 0x17C(r31)
sub r0, r0, r5
stw r0, 0xC(r5)
bl 0x142FD4
.loc_0x90:
extsh. r0, r30
ble- .loc_0xA0
mr r3, r31
bl -0x2AA510
.loc_0xA0:
lwz r0, 0x14(r1)
mr r3, r31
lwz r31, 0xC(r1)
lwz r30, 0x8(r1)
mtlr r0
addi r1, r1, 0x10
blr
*/
}
/*
* --INFO--
* Address: 802CE5E4
* Size: 000010
*/
void SnakeWhole::Mgr::getEnemy(int)
{
/*
.loc_0x0:
mulli r0, r4, 0x340
lwz r3, 0x44(r3)
add r3, r3, r0
blr
*/
}
/*
* --INFO--
* Address: 802CE5F4
* Size: 000068
*/
void SnakeWhole::Mgr::loadModelData()
{
/*
.loc_0x0:
stwu r1, -0x10(r1)
mflr r0
stw r0, 0x14(r1)
stw r31, 0xC(r1)
mr r31, r3
bl -0x19E4FC
li r5, 0
b .loc_0x40
.loc_0x20:
lwz r3, 0x80(r4)
rlwinm r0,r5,2,14,29
addi r5, r5, 0x1
lwzx r3, r3, r0
lwz r0, 0xC(r3)
rlwinm r0,r0,0,20,15
ori r0, r0, 0x2000
stw r0, 0xC(r3)
.loc_0x40:
lwz r4, 0x1C(r31)
rlwinm r0,r5,0,16,31
lhz r3, 0x7C(r4)
cmplw r0, r3
blt+ .loc_0x20
lwz r0, 0x14(r1)
lwz r31, 0xC(r1)
mtlr r0
addi r1, r1, 0x10
blr
*/
}
/*
* --INFO--
* Address: 802CE65C
* Size: 0000B0
*/
SnakeWhole::Mgr::~Mgr()
{
/*
.loc_0x0:
stwu r1, -0x10(r1)
mflr r0
stw r0, 0x14(r1)
stw r31, 0xC(r1)
mr r31, r4
stw r30, 0x8(r1)
mr. r30, r3
beq- .loc_0x94
lis r3, 0x804D
addi r3, r3, 0x2358
stw r3, 0x0(r30)
addi r0, r3, 0x38
stw r0, 0x4(r30)
beq- .loc_0x84
lis r3, 0x804B
subi r3, r3, 0x760
stw r3, 0x0(r30)
addi r0, r3, 0x38
stw r0, 0x4(r30)
beq- .loc_0x84
lis r3, 0x804B
addic. r0, r30, 0x4
subi r3, r3, 0x5304
stw r3, 0x0(r30)
addi r0, r3, 0x38
stw r0, 0x4(r30)
beq- .loc_0x84
lis r4, 0x804B
addi r3, r30, 0x4
subi r0, r4, 0x5324
li r4, 0
stw r0, 0x4(r30)
bl 0x142EAC
.loc_0x84:
extsh. r0, r31
ble- .loc_0x94
mr r3, r30
bl -0x2AA638
.loc_0x94:
lwz r0, 0x14(r1)
mr r3, r30
lwz r31, 0xC(r1)
lwz r30, 0x8(r1)
mtlr r0
addi r1, r1, 0x10
blr
*/
}
/*
* --INFO--
* Address: 802CE70C
* Size: 000008
*/
u32 SnakeWhole::Mgr::getEnemyTypeID() { return 0x46; }
/*
* --INFO--
* Address: 802CE714
* Size: 00002C
*/
void SnakeWhole::Mgr::doLoadBmd(void*)
{
/*
.loc_0x0:
stwu r1, -0x10(r1)
mflr r0
lis r5, 0x2124
mr r3, r4
stw r0, 0x14(r1)
addi r4, r5, 0x30
bl -0x25EE98
lwz r0, 0x14(r1)
mtlr r0
addi r1, r1, 0x10
blr
*/
}
/*
* --INFO--
* Address: 802CE740
* Size: 000050
*/
void SnakeWhole::Parms::read(Stream&)
{
/*
.loc_0x0:
stwu r1, -0x10(r1)
mflr r0
stw r0, 0x14(r1)
stw r31, 0xC(r1)
mr r31, r4
stw r30, 0x8(r1)
mr r30, r3
bl 0x145098
mr r4, r31
addi r3, r30, 0xE0
bl 0x14508C
mr r4, r31
addi r3, r30, 0x7F8
bl 0x145080
lwz r0, 0x14(r1)
lwz r31, 0xC(r1)
lwz r30, 0x8(r1)
mtlr r0
addi r1, r1, 0x10
blr
*/
}
/*
* --INFO--
* Address: 802CE790
* Size: 000008
*/
SnakeWhole::Mgr::@4 @~Mgr()
{
/*
.loc_0x0:
subi r3, r3, 0x4
b -0x138
*/
}
} // namespace Game
| [
"84647527+intns@users.noreply.github.com"
] | 84647527+intns@users.noreply.github.com |
f395b73c10ff310d0d7a09a24c152216ea3af9fa | c6ecad18dd41ea69c22baf78dfeb95cf9ba547d0 | /src/boost_1_42_0/libs/interprocess/test/upgradable_mutex_test.cpp | 97deaaec29b5111e450cbdb6cbd358c82afea5d8 | [
"BSL-1.0"
] | permissive | neuschaefer/qnap-gpl | b1418d504ebe17d7a31a504d315edac309430fcf | 7bb76f6cfe7abef08777451a75924f667cca335b | refs/heads/master | 2022-08-16T17:47:37.015870 | 2020-05-24T18:56:05 | 2020-05-24T18:56:05 | 266,605,194 | 3 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 6,590 | cpp | //////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2004-2009. 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/interprocess for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#include <boost/interprocess/detail/config_begin.hpp>
#include "mutex_test_template.hpp"
#include "sharable_mutex_test_template.hpp"
#include <boost/interprocess/sync/interprocess_upgradable_mutex.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/interprocess/sync/sharable_lock.hpp>
#include <boost/interprocess/sync/upgradable_lock.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include "util.hpp"
int main ()
{
using namespace boost::interprocess;
test::test_all_lock<interprocess_upgradable_mutex>();
test::test_all_mutex<true, interprocess_upgradable_mutex>();
test::test_all_sharable_mutex<true, interprocess_upgradable_mutex>();
//Test lock transition
{
typedef interprocess_upgradable_mutex Mutex;
Mutex mut;
Mutex mut2;
//Conversions to scoped_lock
{
scoped_lock<Mutex> lock(mut);
scoped_lock<Mutex> e_lock(boost::interprocess::move(lock));
lock.swap(e_lock);
}
{
scoped_lock<Mutex> lock(mut);
scoped_lock<Mutex> e_lock(mut2);
e_lock = boost::interprocess::move(lock);
}
{
upgradable_lock<Mutex> u_lock(mut);
//This calls unlock_upgradable_and_lock()
scoped_lock<Mutex> e_lock(boost::interprocess::move(u_lock));
}
{
upgradable_lock<Mutex> u_lock(mut);
//This calls unlock_upgradable_and_lock()
scoped_lock<Mutex> e_lock(mut2);
scoped_lock<Mutex> moved(boost::interprocess::move(u_lock));
e_lock = boost::interprocess::move(moved);
}
{
upgradable_lock<Mutex> u_lock(mut);
//This calls try_unlock_upgradable_and_lock()
scoped_lock<Mutex> e_lock(boost::interprocess::move(u_lock), try_to_lock);
}
{
upgradable_lock<Mutex> u_lock(mut);
//This calls try_unlock_upgradable_and_lock()
scoped_lock<Mutex> e_lock(mut2);
scoped_lock<Mutex> moved(boost::interprocess::move(u_lock), try_to_lock);
e_lock = boost::interprocess::move(moved);
}
{
boost::posix_time::ptime t = test::delay(100);
upgradable_lock<Mutex> u_lock(mut);
//This calls timed_unlock_upgradable_and_lock()
scoped_lock<Mutex> e_lock(boost::interprocess::move(u_lock), t);
}
{
boost::posix_time::ptime t = test::delay(100);
upgradable_lock<Mutex> u_lock(mut);
//This calls timed_unlock_upgradable_and_lock()
scoped_lock<Mutex> e_lock(mut2);
scoped_lock<Mutex> moved(boost::interprocess::move(u_lock), t);
e_lock = boost::interprocess::move(moved);
}
{
sharable_lock<Mutex> s_lock(mut);
//This calls try_unlock_sharable_and_lock()
scoped_lock<Mutex> e_lock(boost::interprocess::move(s_lock), try_to_lock);
}
{
sharable_lock<Mutex> s_lock(mut);
//This calls try_unlock_sharable_and_lock()
scoped_lock<Mutex> e_lock(mut2);
scoped_lock<Mutex> moved(boost::interprocess::move(s_lock), try_to_lock);
e_lock = boost::interprocess::move(moved);
}
//Conversions to upgradable_lock
{
upgradable_lock<Mutex> lock(mut);
upgradable_lock<Mutex> u_lock(boost::interprocess::move(lock));
lock.swap(u_lock);
}
{
upgradable_lock<Mutex> lock(mut);
upgradable_lock<Mutex> u_lock(mut2);
upgradable_lock<Mutex> moved(boost::interprocess::move(lock));
u_lock = boost::interprocess::move(moved);
}
{
sharable_lock<Mutex> s_lock(mut);
//This calls unlock_sharable_and_lock_upgradable()
upgradable_lock<Mutex> u_lock(boost::interprocess::move(s_lock), try_to_lock);
}
{
sharable_lock<Mutex> s_lock(mut);
//This calls unlock_sharable_and_lock_upgradable()
upgradable_lock<Mutex> u_lock(mut2);
upgradable_lock<Mutex> moved(boost::interprocess::move(s_lock), try_to_lock);
u_lock = boost::interprocess::move(moved);
}
{
scoped_lock<Mutex> e_lock(mut);
//This calls unlock_and_lock_upgradable()
upgradable_lock<Mutex> u_lock(boost::interprocess::move(e_lock));
}
{
scoped_lock<Mutex> e_lock(mut);
//This calls unlock_and_lock_upgradable()
upgradable_lock<Mutex> u_lock(mut2);
upgradable_lock<Mutex> moved(boost::interprocess::move(e_lock));
u_lock = boost::interprocess::move(moved);
}
//Conversions to sharable_lock
{
sharable_lock<Mutex> lock(mut);
sharable_lock<Mutex> s_lock(boost::interprocess::move(lock));
lock.swap(s_lock);
}
{
sharable_lock<Mutex> lock(mut);
sharable_lock<Mutex> s_lock(mut2);
sharable_lock<Mutex> moved(boost::interprocess::move(lock));
s_lock = boost::interprocess::move(moved);
}
{
upgradable_lock<Mutex> u_lock(mut);
//This calls unlock_upgradable_and_lock_sharable()
sharable_lock<Mutex> s_lock(boost::interprocess::move(u_lock));
}
{
upgradable_lock<Mutex> u_lock(mut);
//This calls unlock_upgradable_and_lock_sharable()
sharable_lock<Mutex> s_lock(mut2);
sharable_lock<Mutex> moved(boost::interprocess::move(u_lock));
s_lock = boost::interprocess::move(moved);
}
{
scoped_lock<Mutex> e_lock(mut);
//This calls unlock_and_lock_sharable()
sharable_lock<Mutex> s_lock(boost::interprocess::move(e_lock));
}
{
scoped_lock<Mutex> e_lock(mut);
//This calls unlock_and_lock_sharable()
sharable_lock<Mutex> s_lock(mut2);
sharable_lock<Mutex> moved(boost::interprocess::move(e_lock));
s_lock = boost::interprocess::move(moved);
}
}
return 0;
}
#include <boost/interprocess/detail/config_end.hpp>
| [
"j.neuschaefer@gmx.net"
] | j.neuschaefer@gmx.net |
9fb1a8c954e546bdbee72604224d2633ef066a42 | f550424e3c3ba336255420f8bbf2012a12e75cea | /3_attempt/serverwindow.cpp | d48144b2fa087a7532ba671790296950c5f52f68 | [] | no_license | Akhil2453/SupervisorGatewayControlSystem | f4fa1a8a85c12c2bdb0472ffb0795d5dcc88ba92 | b0cd409ae8d8dcee6cdc09e45355b88597e4dd54 | refs/heads/master | 2021-05-08T16:34:09.590926 | 2018-03-14T08:41:04 | 2018-03-14T08:41:04 | 120,163,259 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,692 | cpp | #include "serverwindow.h"
#include "ui_serverwindow.h"
#include "ui_clientwindow.h"
#include <QDateTime>
#include <QDebug>
#include <QtWidgets>
QString s;
QString t;
QString u;
serverWindow::serverWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::serverWindow)
{
ui->setupUi(this);
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(Time()));
timer->start(500);
}
serverWindow::~serverWindow()
{
delete ui;
}
void serverWindow::Time()
{
QTime time = QTime::currentTime();
QString time_txt = time.toString("hh : mm : ss");
ui->labelTime->setText(time_txt);
}
void serverWindow::on_ONpushButton_clicked()
{
QPixmap pic(":ON.jpg");
ui->indicator1->setPixmap(pic);
cWind = new clientWindow(this);
cWind->setLineText(s, t, u);
cWind->show();
}
void serverWindow::on_OFFpushButton_clicked()
{
QPixmap pic(":OFF.jpg");
ui->indicator2->setPixmap(pic);
//cWind = new clientWindow(this);
//cWind->close();
}
void serverWindow::on_AzimuthDial_actionTriggered(int action)
{
if(action>=0){
int a = ui->AzimuthDial->value();
s = QString::number(a);
qDebug() << "Azimuth" ;
qDebug() << s << endl;
}
}
void serverWindow::on_CrsElDial_actionTriggered(int action)
{
if(action>=0){
int a = ui->CrsElDial->value();
t = QString::number(a);
qDebug() << "Cross Elevation" ;
qDebug() << t << endl;
}
}
void serverWindow::on_ElDial_actionTriggered(int action)
{
if(action>=0){
int a = ui->ElDial->value();
u = QString::number(a);
qDebug() << "Elevation" ;
qDebug() << u << endl;
}
}
| [
"akhil.menon94@gmail.com"
] | akhil.menon94@gmail.com |
c6b5f270879d7d6581f3302353e4fbb425491278 | abff3f461cd7d740cfc1e675b23616ee638e3f1e | /opencascade/GeomLib.hxx | b51028d2fc7d3dbb37f96b58118cca991b923397 | [
"Apache-2.0"
] | permissive | CadQuery/pywrap | 4f93a4191d3f033f67e1fc209038fc7f89d53a15 | f3bcde70fd66a2d884fa60a7a9d9f6aa7c3b6e16 | refs/heads/master | 2023-04-27T04:49:58.222609 | 2023-02-10T07:56:06 | 2023-02-10T07:56:06 | 146,502,084 | 22 | 25 | Apache-2.0 | 2023-05-01T12:14:52 | 2018-08-28T20:18:59 | C++ | UTF-8 | C++ | false | false | 12,765 | hxx | // Created on: 1993-07-07
// Created by: Jean Claude VAUTHIER
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _GeomLib_HeaderFile
#define _GeomLib_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_SequenceOfReal.hxx>
class Geom_Curve;
class gp_Ax2;
class Geom2d_Curve;
class gp_GTrsf2d;
class Adaptor3d_CurveOnSurface;
class Geom_BoundedCurve;
class gp_Pnt;
class gp_Vec;
class Geom_BoundedSurface;
class gp_Dir;
class Adaptor3d_Curve;
class Geom_BSplineSurface;
class Geom_BezierSurface;
class Geom_Surface;
class gp_Pnt2d;
class GeomLib_MakeCurvefromApprox;
class GeomLib_Interpolate;
class GeomLib_DenominatorMultiplier;
class GeomLib_CheckBSplineCurve;
class GeomLib_Check2dBSplineCurve;
class GeomLib_IsPlanarSurface;
class GeomLib_Tool;
class GeomLib_PolyFunc;
class GeomLib_LogSample;
//! Geom Library. This package provides an
//! implementation of functions for basic computation
//! on geometric entity from packages Geom and Geom2d.
class GeomLib
{
public:
DEFINE_STANDARD_ALLOC
//! Computes the curve 3d from package Geom
//! corresponding to curve 2d from package Geom2d, on
//! the plan defined with the local coordinate system
//! Position.
Standard_EXPORT static Handle(Geom_Curve) To3d (const gp_Ax2& Position, const Handle(Geom2d_Curve)& Curve2d);
//! Computes the curve 3d from package Geom
//! corresponding to the curve 3d from package Geom,
//! transformed with the transformation <GTrsf>
//! WARNING : this method may return a null Handle if
//! it's impossible to compute the transformation of
//! a curve. It's not implemented when :
//! 1) the curve is an infinite parabola or hyperbola
//! 2) the curve is an offsetcurve
Standard_EXPORT static Handle(Geom2d_Curve) GTransform (const Handle(Geom2d_Curve)& Curve, const gp_GTrsf2d& GTrsf);
//! Make the curve Curve2dPtr have the imposed
//! range First to List the most economic way,
//! that is if it can change the range without
//! changing the nature of the curve it will try
//! to do that. Otherwise it will produce a Bspline
//! curve that has the required range
Standard_EXPORT static void SameRange (const Standard_Real Tolerance, const Handle(Geom2d_Curve)& Curve2dPtr, const Standard_Real First, const Standard_Real Last, const Standard_Real RequestedFirst, const Standard_Real RequestedLast, Handle(Geom2d_Curve)& NewCurve2dPtr);
Standard_EXPORT static void BuildCurve3d (const Standard_Real Tolerance, Adaptor3d_CurveOnSurface& CurvePtr, const Standard_Real FirstParameter, const Standard_Real LastParameter, Handle(Geom_Curve)& NewCurvePtr, Standard_Real& MaxDeviation, Standard_Real& AverageDeviation, const GeomAbs_Shape Continuity = GeomAbs_C1, const Standard_Integer MaxDegree = 14, const Standard_Integer MaxSegment = 30);
Standard_EXPORT static void AdjustExtremity (Handle(Geom_BoundedCurve)& Curve, const gp_Pnt& P1, const gp_Pnt& P2, const gp_Vec& T1, const gp_Vec& T2);
//! Extends the bounded curve Curve to the point Point.
//! The extension is built:
//! - at the end of the curve if After equals true, or
//! - at the beginning of the curve if After equals false.
//! The extension is performed according to a degree of
//! continuity equal to Cont, which in its turn must be equal to 1, 2 or 3.
//! This function converts the bounded curve Curve into a BSpline curve.
//! Warning
//! - Nothing is done, and Curve is not modified if Cont is
//! not equal to 1, 2 or 3.
//! - It is recommended that the extension should not be
//! too large with respect to the size of the bounded
//! curve Curve: Point must not be located too far from
//! one of the extremities of Curve.
Standard_EXPORT static void ExtendCurveToPoint (Handle(Geom_BoundedCurve)& Curve, const gp_Pnt& Point, const Standard_Integer Cont, const Standard_Boolean After);
//! Extends the bounded surface Surf along one of its
//! boundaries. The chord length of the extension is equal to Length.
//! The direction of the extension is given as:
//! - the u parametric direction of Surf, if InU equals true, or
//! - the v parametric direction of Surf, if InU equals false.
//! In this parametric direction, the extension is built on the side of:
//! - the last parameter of Surf, if After equals true, or
//! - the first parameter of Surf, if After equals false.
//! The extension is performed according to a degree of
//! continuity equal to Cont, which in its turn must be equal to 1, 2 or 3.
//! This function converts the bounded surface Surf into a BSpline surface.
//! Warning
//! - Nothing is done, and Surf is not modified if Cont is
//! not equal to 1, 2 or 3.
//! - It is recommended that Length, the size of the
//! extension should not be too large with respect to the
//! size of the bounded surface Surf.
//! - Surf must not be a periodic BSpline surface in the
//! parametric direction corresponding to the direction of extension.
Standard_EXPORT static void ExtendSurfByLength (Handle(Geom_BoundedSurface)& Surf, const Standard_Real Length, const Standard_Integer Cont, const Standard_Boolean InU, const Standard_Boolean After);
//! Compute axes of inertia, of some points -- -- --
//! <Axe>.Location() is the BaryCentre -- -- -- -- --
//! <Axe>.XDirection is the axe of upper inertia -- -- --
//! -- <Axe>.Direction is the Normal to the average plane
//! -- -- -- IsSingular is True if points are on line --
//! Tol is used to determine singular cases.
Standard_EXPORT static void AxeOfInertia (const TColgp_Array1OfPnt& Points, gp_Ax2& Axe, Standard_Boolean& IsSingular, const Standard_Real Tol = 1.0e-7);
//! Compute principale axes of inertia, and dispertion
//! value of some points.
Standard_EXPORT static void Inertia (const TColgp_Array1OfPnt& Points, gp_Pnt& Bary, gp_Dir& XDir, gp_Dir& YDir, Standard_Real& Xgap, Standard_Real& YGap, Standard_Real& ZGap);
//! Warning! This assume that the InParameter is an increasing sequence
//! of real number and it will not check for that : Unpredictable
//! result can happen if this is not satisfied. It is the caller
//! responsability to check for that property.
//!
//! This method makes uniform NumPoints segments S1,...SNumPoints out
//! of the segment defined by the first parameter and the
//! last parameter ofthe InParameter ; keeps only one
//! point of the InParameters set of parameter in each of
//! the uniform segments taking care of the first and the
//! last parameters. For the ith segment the element of
//! the InParameter is the one that is the first to exceed
//! the midpoint of the segment and to fall before the
//! midpoint of the next segment
//! There will be at the end at most NumPoints + 1 if
//! NumPoints > 2 in the OutParameters Array
Standard_EXPORT static void RemovePointsFromArray (const Standard_Integer NumPoints, const TColStd_Array1OfReal& InParameters, Handle(TColStd_HArray1OfReal)& OutParameters);
//! this makes sure that there is at least MinNumPoints
//! in OutParameters taking into account the parameters in
//! the InParameters array provided those are in order,
//! that is the sequence of real in the InParameter is strictly
//! non decreasing
Standard_EXPORT static void DensifyArray1OfReal (const Standard_Integer MinNumPoints, const TColStd_Array1OfReal& InParameters, Handle(TColStd_HArray1OfReal)& OutParameters);
Standard_EXPORT static void FuseIntervals (const TColStd_Array1OfReal& Interval1, const TColStd_Array1OfReal& Interval2, TColStd_SequenceOfReal& Fusion, const Standard_Real Confusion = 1.0e-9);
//! this will compute the maximum distance at the
//! parameters given in the Parameters array by
//! evaluating each parameter the two curves and taking
//! the maximum of the evaluated distance
Standard_EXPORT static void EvalMaxParametricDistance (const Adaptor3d_Curve& Curve, const Adaptor3d_Curve& AReferenceCurve, const Standard_Real Tolerance, const TColStd_Array1OfReal& Parameters, Standard_Real& MaxDistance);
//! this will compute the maximum distancef at the parameters
//! given in the Parameters array by projecting from the Curve
//! to the reference curve and taking the minimum distance
//! Than the maximum will be taken on those minimas.
Standard_EXPORT static void EvalMaxDistanceAlongParameter (const Adaptor3d_Curve& Curve, const Adaptor3d_Curve& AReferenceCurve, const Standard_Real Tolerance, const TColStd_Array1OfReal& Parameters, Standard_Real& MaxDistance);
//! Cancel,on the boudaries,the denominator first derivative
//! in the directions wished by the user and set its value to 1.
Standard_EXPORT static void CancelDenominatorDerivative (Handle(Geom_BSplineSurface)& BSurf, const Standard_Boolean UDirection, const Standard_Boolean VDirection);
Standard_EXPORT static Standard_Integer NormEstim (const Handle(Geom_Surface)& S, const gp_Pnt2d& UV, const Standard_Real Tol, gp_Dir& N);
//! This method defines if opposite boundaries of surface
//! coincide with given tolerance
Standard_EXPORT static void IsClosed(const Handle(Geom_Surface)& S, const Standard_Real Tol,
Standard_Boolean& isUClosed, Standard_Boolean& isVClosed);
//! Returns true if the poles of U1 isoline and the poles of
//! U2 isoline of surface are identical according to tolerance criterion.
//! For rational surfaces Weights(i)*Poles(i) are checked.
Standard_EXPORT static Standard_Boolean IsBSplUClosed(const Handle(Geom_BSplineSurface)& S,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real Tol);
//! Returns true if the poles of V1 isoline and the poles of
//! V2 isoline of surface are identical according to tolerance criterion.
//! For rational surfaces Weights(i)*Poles(i) are checked.
Standard_EXPORT static Standard_Boolean IsBSplVClosed(const Handle(Geom_BSplineSurface)& S,
const Standard_Real V1,
const Standard_Real V2,
const Standard_Real Tol);
//! Returns true if the poles of U1 isoline and the poles of
//! U2 isoline of surface are identical according to tolerance criterion.
Standard_EXPORT static Standard_Boolean IsBzUClosed(const Handle(Geom_BezierSurface)& S,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real Tol);
//! Returns true if the poles of V1 isoline and the poles of
//! V2 isoline of surface are identical according to tolerance criterion.
Standard_EXPORT static Standard_Boolean IsBzVClosed(const Handle(Geom_BezierSurface)& S,
const Standard_Real V1,
const Standard_Real V2,
const Standard_Real Tol);
protected:
private:
friend class GeomLib_MakeCurvefromApprox;
friend class GeomLib_Interpolate;
friend class GeomLib_DenominatorMultiplier;
friend class GeomLib_CheckBSplineCurve;
friend class GeomLib_Check2dBSplineCurve;
friend class GeomLib_IsPlanarSurface;
friend class GeomLib_Tool;
friend class GeomLib_PolyFunc;
friend class GeomLib_LogSample;
};
#endif // _GeomLib_HeaderFile
| [
"adam.jan.urbanczyk@gmail.com"
] | adam.jan.urbanczyk@gmail.com |
18c9d4c5d0878211c4ba1ee8707f04ea02480b14 | b0fc1db07262f2432caaccda3ce1d69f68bb32a2 | /src/format.cpp | 5891878440b01fa2f4a72698744584d11c946e47 | [
"MIT"
] | permissive | klickers/CppND-System-Monitor | 035af05e40916c77da88819ddf04510d915741ef | 855043ba502cc6a277a53eea8ae044f82c1e3eb0 | refs/heads/master | 2022-08-19T18:43:31.740180 | 2020-05-25T17:53:53 | 2020-05-25T17:53:53 | 266,474,559 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 949 | cpp | #include <string>
#include "format.h"
using std::string;
// DONE: Complete this helper function
// INPUT: Long int measuring seconds
// OUTPUT: HH:MM:SS
// REMOVE: [[maybe_unused]] once you define the function
string Format::ElapsedTime(long seconds) {
string hoursString, minutesString, secondsString;
long secondsLeftover = seconds % (60 * 60);
long hours = (seconds - secondsLeftover) / (60 * 60);
secondsLeftover %= 60;
long minutes = (seconds - secondsLeftover - hours*60*60) / 60;
long secs = secondsLeftover;
if (hours < 10)
hoursString = "0" + std::to_string(hours);
else
hoursString = std::to_string(hours);
if (minutes < 10)
minutesString = "0" + std::to_string(minutes);
else
minutesString = std::to_string(minutes);
if (secs < 10)
secondsString = "0" + std::to_string(secs);
else
secondsString = std::to_string(secs);
return hoursString + ":" + minutesString + ":" + secondsString;
} | [
"bluebirid228@gmail.com"
] | bluebirid228@gmail.com |
3a62825c3254c49b7933c977d957f65cefbbe201 | b96a1a03a0b34dd78d02e7293608f3ff7e6fbcd7 | /Tutorial20_MouseInputandDeltaTime/Game.cpp | 9a9b0766aca8ee02ca165a716134e980d43907c9 | [] | no_license | finoriko/CppOpenGL | e9cd67616516b536e56078230f30d011b3ee2107 | 1d5ea29c504924b0b8632371fd0e66ab6c7c576e | refs/heads/master | 2021-05-25T17:37:54.538440 | 2020-06-14T14:56:55 | 2020-06-14T14:56:55 | 253,848,602 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 9,337 | cpp | #include "Game.h"
//Private functions
void Game::initGLFW()
{
//INIT GLFW
if (glfwInit() == GLFW_FALSE)
{
std::cout << "ERROR::GLFW_INIT_FAILED" << "\n";
glfwTerminate();
}
}
void Game::initWindow(
const char* title,
bool resizable
)
{
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, this->GL_VERSION_MAJOR);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, this->GL_VERSION_MINOR);
glfwWindowHint(GLFW_RESIZABLE, resizable);
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); MAC OS
this->window = glfwCreateWindow(this->WINDOW_WIDTH, this->WINDOW_HEIGHT, title, NULL, NULL);
if (this->window == nullptr)
{
std::cout << "ERROR::GLFW_WINDOW_INIT_FAILED" << "\n";
glfwTerminate();
}
glfwGetFramebufferSize(this->window, &this->framebufferWidth, &this->framebufferHeight);
glfwSetFramebufferSizeCallback(window, Game::framebuffer_resize_callback);
//IMPORTANT WHITH PERSPECTIVE MATRIX!!!
//glViewport(0, 0, framebufferWidth, framebufferHeight);
glfwMakeContextCurrent(this->window); //IMPORTANT!!
}
void Game::initGLEW()
{
glewExperimental = GL_TRUE;
//Error
if (glewInit() != GLEW_OK)
{
std::cout << "ERROR::MAIN.CPP::GLEW_INIT_FAILED" << "\n";
glfwTerminate();
}
}
void Game::initOpenGLOptions()
{
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
//Input
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
}
void Game::initMatrices()
{
this->ViewMatrix = glm::mat4(1.f);
this->ViewMatrix = glm::lookAt(this->camPosition, this->camPosition + this->camFront, this->worldUp);
this->ProjectionMatrix = glm::mat4(1.f);
this->ProjectionMatrix = glm::perspective(
glm::radians(this->fov),
static_cast<float>(this->framebufferWidth) / this->framebufferHeight,
this->nearPlane,
this->farPlane
);
}
void Game::initShaders()
{
this->shaders.push_back(new Shader(this->GL_VERSION_MAJOR, this->GL_VERSION_MINOR,
"vertex_core.glsl", "fragment_core.glsl"));
}
void Game::initTextures()
{
//TEXTURE 0
this->textures.push_back(new Texture("Images/pusheen.png", GL_TEXTURE_2D));
this->textures.push_back(new Texture("Images/pusheen_specular.png", GL_TEXTURE_2D));
//TEXTURE 1
this->textures.push_back(new Texture("Images/container.png", GL_TEXTURE_2D));
this->textures.push_back(new Texture("Images/container_specular.png", GL_TEXTURE_2D));
}
void Game::initMaterials()
{
this->materials.push_back(new Material(glm::vec3(0.1f), glm::vec3(1.f), glm::vec3(1.f),
0, 1));
}
void Game::initMeshes()
{
this->meshes.push_back(new Mesh(&Pyramid(),
glm::vec3(0.f),
glm::vec3(0.f),
glm::vec3(1.f)
));
this->meshes.push_back(
new Mesh(
&Quad(),
glm::vec3(0.f),
glm::vec3(0.f),
glm::vec3(1.f)
)
);
}
void Game::initLights()
{
this->lights.push_back(new glm::vec3(0.f, 0.f, 1.f));
}
void Game::initUniforms()
{
//INIT UNIFORMS
this->shaders[SHADER_CORE_PROGRAM]->setMat4fv(ViewMatrix, "ViewMatrix");
this->shaders[SHADER_CORE_PROGRAM]->setMat4fv(ProjectionMatrix, "ProjectionMatrix");
this->shaders[SHADER_CORE_PROGRAM]->setVec3f(*this->lights[0], "lightPos0");
this->shaders[SHADER_CORE_PROGRAM]->setVec3f(this->camPosition, "cameraPos");
}
void Game::updateUniforms()
{
//update view matrix(camera)
this->ViewMatrix = glm::lookAt(this->camPosition, this->camPosition + this->camFront, this->worldUp);
this->shaders[SHADER_CORE_PROGRAM]->setMat4fv(ViewMatrix, "ViewMatrix");
glfwGetFramebufferSize(this->window, &this->framebufferWidth, &this->framebufferHeight);
ProjectionMatrix = glm::perspective(
glm::radians(fov),
static_cast<float>(framebufferWidth) / framebufferHeight,
nearPlane,
farPlane
);
this->shaders[SHADER_CORE_PROGRAM]->setMat4fv(ProjectionMatrix, "ProjectionMatrix");
}
//Constructors / Destructors
Game::Game(
const char* title,
const int WINDOW_WIDTH, const int WINDOW_HEIGHT,
const int GL_VERSION_MAJOR, const int GL_VERSION_MINOR,
bool resizable
)
:
WINDOW_WIDTH(WINDOW_WIDTH),
WINDOW_HEIGHT(WINDOW_HEIGHT),
GL_VERSION_MAJOR(GL_VERSION_MAJOR),
GL_VERSION_MINOR(GL_VERSION_MINOR)
{
//Init variables
this->window = nullptr;
this->framebufferWidth = this->WINDOW_WIDTH;
this->framebufferHeight = this->WINDOW_HEIGHT;
this->camPosition = glm::vec3(0.f, 0.f, 1.f);
this->worldUp = glm::vec3(0.f, 1.f, 0.f);
this->camFront = glm::vec3(0.f, 0.f, -1.f);
this->ViewMatrix = glm::mat4(1.f);
this->ViewMatrix = glm::lookAt(this->camPosition, this->camPosition + this->camFront, this->worldUp);
this->fov = 90.f;
this->nearPlane = 0.1f;
this->farPlane = 1000.f;
this->dt = 0.f;
this->curTime = 0.f;
this->lastTime = 0.f;
this->lastMouseX = 0.0;
this->lastMouseY = 0.0;
this->mouseX = 0.0;
this->mouseY = 0.0;
this->mouseOffsetX = 0.0;
this->mouseOffsetY = 0.0;
this->firstMouse = true;
this->ProjectionMatrix = glm::mat4(1.f);
this->ProjectionMatrix = glm::perspective(
glm::radians(this->fov),
static_cast<float>(this->framebufferWidth) / this->framebufferHeight,
this->nearPlane,
this->farPlane
);
this->initGLFW();
this->initWindow(title, resizable);
this->initGLEW();
this->initOpenGLOptions();
this->initMatrices();
this->initShaders();
this->initTextures();
this->initMaterials();
this->initMeshes();
this->initLights();
this->initUniforms();
}
Game::~Game()
{
glfwDestroyWindow(this->window);
glfwTerminate();
for (size_t i = 0; i < this->shaders.size(); i++)
delete this->shaders[i];
for (size_t i = 0; i < this->textures.size(); i++)
delete this->textures[i];
for (size_t i = 0; i < this->materials.size(); i++)
delete this->materials[i];
for (size_t i = 0; i < this->meshes.size(); i++)
delete this->meshes[i];
for (size_t i = 0; i < this->lights.size(); i++)
delete this->lights[i];
}
int Game::getWindowShouldClose()
{
return glfwWindowShouldClose(this->window);
}
//Modifier
void Game::setWindowShouldClose()
{
glfwSetWindowShouldClose(this->window, GLFW_TRUE);
}
//Functions
void Game::updateDT()
{
this->curTime = static_cast<float>(glfwGetTime());
this->dt = this->curTime - this->lastTime;
this->lastTime = this->curTime;
std::cout << "DT: " << this->dt << std::endl << "Mouse OffsetX:" << this->mouseOffsetX << std::endl<<"Mouse OffsetY:"
<<this->mouseOffsetY<<std::endl;
}
void Game::updateMouseInput()
{
glfwGetCursorPos(this->window, &this->mouseX, &this->mouseY);
if (this->firstMouse)
{
this->lastMouseX = this->mouseX;
this->lastMouseY = this->mouseY;
this->firstMouse = false;
}
//Calc offset
this->mouseOffsetX = this->mouseX - this->lastMouseX;
this->mouseOffsetY = this->lastMouseY - this->mouseY;
//Set last X and Y
this->lastMouseX = this->mouseX;
this->lastMouseY = this->mouseY;
}
void Game::updateKeyboardInput()
{
//Program
if (glfwGetKey(this->window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
{
glfwSetWindowShouldClose(this->window, GLFW_TRUE);
}
//Cameara
if (glfwGetKey(this->window, GLFW_KEY_W) == GLFW_PRESS)
{
this->camPosition.z -= 0.05f;
}
if (glfwGetKey(this->window, GLFW_KEY_S) == GLFW_PRESS)
{
this->camPosition.z += 0.05f;
}
if (glfwGetKey(this->window, GLFW_KEY_A) == GLFW_PRESS)
{
this->camPosition.x -= 0.05f;
}
if (glfwGetKey(this->window, GLFW_KEY_D) == GLFW_PRESS)
{
this->camPosition.x += 0.05f;
}
if (glfwGetKey(this->window, GLFW_KEY_C) == GLFW_PRESS)
{
this->camPosition.y -= 0.05f;
}
if (glfwGetKey(this->window, GLFW_KEY_SPACE) == GLFW_PRESS)
{
this->camPosition.y += 0.05f;
}
}
void Game::updateInput()
{
glfwPollEvents();
this->updateKeyboardInput();
this->updateMouseInput();
}
void Game::update()
{
//Update Input
this->updateDT();
this->updateInput();
}
void Game::render()
{
//UPDATE ---
//updateInput(window);
//update
//Draw
//clear
glClearColor(0.f, 0.f, 0.f, 1.f); // 색 넣기
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); //초기화
//use a program
//glUseProgram(core_program);
//this->shaders[SHADER_CORE_PROGRAM]->set1i(0, "texture0");
//this->shaders[SHADER_CORE_PROGRAM]->set1i(1, "texture1");
this->updateUniforms();
this->materials[MAT_1]->sendToShader(*this->shaders[SHADER_CORE_PROGRAM]);
//this->shaders[SHADER_CORE_PROGRAM]->setMat4fv(ProjectionMatrix, "ProjectionMatrix");
//glUniformMatrix4fv(glGetUniformLocation(core_program, "ProjectionMatrix"), 1, GL_FALSE, glm::value_ptr(ProjectionMatrix));
this->shaders[SHADER_CORE_PROGRAM]->use();
//Activate texture
/*glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture0);*/
//this->textures[TEX_PUSHEEN]->bind(0);
//this->textures[TEX_PUSHEEN_SPECULAR]->bind(1);
////Bind vertex array object
////draw
//this->meshes[MESH_QUAD]->render(this->shaders[SHADER_CORE_PROGRAM]);
this->textures[TEX_CONTAINER]->bind(0);
this->textures[TEX_CONTAINER_SPECULAR]->bind(1);
this->meshes[MESH_QUAD]->render(this->shaders[SHADER_CORE_PROGRAM]);
//end draw
glfwSwapBuffers(window);
glFlush();
glBindVertexArray(0);
glUseProgram(0);
glActiveTexture(0);
glBindTexture(GL_TEXTURE_2D, 0);
}
//Static functions
void Game::framebuffer_resize_callback(GLFWwindow* window, int fbW, int fbH)
{
glViewport(0, 0, fbW, fbH);
}
| [
"finoriko@Hotmail.com"
] | finoriko@Hotmail.com |
1c8b770be34322f101458ef1772b1a0c1ed1b057 | bd46b3d0aaa63ff91772aece5059de58f88295e6 | /Source/MyProject/Character/BaseCharacter.h | 67f99cf4dabe894ace2caa809d255dee78d9599f | [] | no_license | peerSW/ProjectTry | e6d1591b29887613c6ad5bb22d63befaae29674e | 883646aa785f5f7732e95cbff0017393f6ffa8ee | refs/heads/main | 2023-05-15T08:00:48.343838 | 2021-06-21T13:03:50 | 2021-06-21T13:03:50 | 361,427,954 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,667 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "BaseCharacter.generated.h"
UCLASS()
class MYPROJECT_API ABaseCharacter : public ACharacter
{
GENERATED_BODY()
public:
// Sets default values for this character's properties
ABaseCharacter();
protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;
/** Top down camera */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
class UCameraComponent* TopDownCameraComponent;
/** Camera boom positioning the camera above the character */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
class USpringArmComponent* CameraBoom;
/** A decal that projects to the cursor location. */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
class UDecalComponent* CursorToWorld;
public:
// Called every frame
virtual void Tick(float DeltaTime) override;
// Called to bind functionality to input
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
/** Returns TopDownCameraComponent subobject **/
FORCEINLINE class UCameraComponent* GetTopDownCameraComponent() const { return TopDownCameraComponent; }
/** Returns CameraBoom subobject **/
FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }
/** Returns CursorToWorld subobject **/
FORCEINLINE class UDecalComponent* GetCursorToWorld() { return CursorToWorld; }
};
| [
"U7031622@anu.edu.au"
] | U7031622@anu.edu.au |
85039f5e39f2eca5db1c1120da325f2a8a3ba7e3 | d762cc2ca3db583e358610e4a2df1dcfea781458 | /GraphicsProgramming/ModelManager.h | 157222b953e5f72ba541e224c1a02279ca91b4cb | [] | no_license | Probably-Jay/GraphicsProgramming | 9571689c1513cd3c22e4938e12a719ac69a5fe02 | eb78cbfcab791cc9c9de270f4f7c68dc7f383fc0 | refs/heads/master | 2022-03-21T19:19:52.007664 | 2019-12-10T23:33:27 | 2019-12-10T23:33:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 934 | h | #pragma once
#include "Model.h"
#include <vector>
#include <map>
class ModelManager
{
public:
ModelManager();
~ModelManager();
bool loadModels();
enum ModelEnum
{
uninitialised,
ball,
cow,
ufo,
beam,
grass,
skybox,
tree,
none
};
Model* getModel(ModelEnum name);
private:
// list of the filepaths for the objects
map<ModelEnum, vector<char*> >filenames {
{ufo,{"models/ufo.obj", "gfx/ufo.png"}},
{beam,{"models/beam.obj", "gfx/Beam.png"}},
{cow,{"models/moo.obj", "gfx/cow.png"}},
{tree,{"models/Poplar_Tree.obj", "gfx/tree.png"}},
{grass,{"models/grassCube.obj", "gfx/grass.png"}},
{ball,{"models/ball.obj", "gfx/light.png"}},
{skybox,{"models/invertedCube.obj", "gfx/kisspng-space-skybox-texture.png"}},
};
map<ModelEnum, Model*> models;
};
//{teapot,{"models/teapot.obj", "gfx/checked.png"}},
//{garfield,{"models/garfiled.obj", "gfx/garfieldskin.png"}}, | [
"1800231@uad.ac.uk"
] | 1800231@uad.ac.uk |
baa3deaf023ac97b37dc8d2cc37ed8716459e6f1 | 590e562120712c1cd40fc2017bcb0b6709aaab18 | /tc/library/copy.h | 5ba6ca4d74ee0ab5b1a67f0bffdda00673873f85 | [
"Apache-2.0"
] | permissive | facebookresearch/TensorComprehensions | 5ac82e0fc1cc8de9b50f42b077ab1a4329a74109 | 680f8c9d61664a78294cd75335091fe3cac2bb72 | refs/heads/master | 2023-05-13T03:05:40.103508 | 2023-04-28T18:02:40 | 2023-04-28T18:02:40 | 120,494,252 | 1,907 | 245 | Apache-2.0 | 2019-10-07T23:34:39 | 2018-02-06T17:11:07 | C++ | UTF-8 | C++ | false | false | 1,567 | h | /**
* Copyright (c) 2017-present, Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include "tc/library/common.h"
namespace tc {
static constexpr auto COPY_DOC = R"DOC(
def copy(float(...) I) -> (O) {
O(...) = I(...)
}
)DOC";
constexpr static auto COPY_TC_NAME = "copy";
namespace {
constexpr static auto COPY_TC = R"TC(
def copy(float(${dimParams}) I) -> (O) {
O(${dimIndices}) = I(${dimIndices})
}
)TC";
} // namespace
std::string
setInputDims(std::string tcStr, int numDims, std::string paramPrefix) {
std::string dimParams, dimIndices;
for (int i = 0; i < numDims; i++) {
dimParams += paramPrefix + std::to_string(i);
dimIndices += "i" + std::to_string(i);
if (i < numDims - 1) {
dimParams += ",";
dimIndices += ",";
}
}
tcStr = replaceString(tcStr, "${dimParams}", dimParams);
tcStr = replaceString(tcStr, "${dimIndices}", dimIndices);
return tcStr;
}
std::string makeCopyTc(int numDims) {
return setInputDims(COPY_TC, numDims, "P");
}
} // namespace tc
| [
"nicolas.vasilache@gmail.com"
] | nicolas.vasilache@gmail.com |
77c32605fdc78286837880c39944b98425c00a80 | d1af6fdbad0e3551deb51b2f94fef704fff94d4b | /src/base/filtertest/filterutilstest.cpp | 6435a9325cba352c611e3a44b5c4f01aef141c5c | [
"BSD-3-Clause"
] | permissive | findMF/findMFBase | f27ca404414b1591ef281b1a0366249202895bbe | 84cb1e603ba9fe521f524c044ec5d956b0d79270 | refs/heads/master | 2021-01-20T21:53:33.043334 | 2015-10-26T13:49:53 | 2015-10-26T13:49:53 | 14,234,328 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,246 | cpp | // Copyright : ETH Zurich
// License : three-clause BSD license
// Authors : Witold Wolski
// for full text refer to files: LICENSE, AUTHORS and COPYRIGHT
#include "base/filter/filter.h"
#include <boost/timer.hpp>
#include <gtest/gtest.h>
#include "base/base/base.h"
#include "base/stats/uniform.h"
#include "base/stats/normal.h"
#include "base/base/cumsum.h"
#include "base/resample/masscomparefunctors.h"
namespace {
// The fixture for testing class Foo.
class FilterUtilsTest : public ::testing::Test {
protected:
std::vector<double> data , dcumsum , res , res2;
// You can remove any or all of the following functions if its body
// is empty.
FilterUtilsTest() {
// You can do set-up work for each test here.
}
virtual ~FilterUtilsTest() {
// You can do clean-up work that doesn't throw exceptions here.
}
// If the constructor and destructor are not enough for setting up
// and cleaning up each test, you can define the following methods:
virtual void SetUp() {
}
virtual void TearDown() {
// Code here will be called immediately after each test (right
// before the destructor).
}
// Objects declared here can be used by all tests in the test case for Foo.
};
/*! \brief test filter function */
TEST_F( FilterUtilsTest,filterTest)
{
double epsilon = 0.000001;
epsilon;
std::vector<double> data;
ralab::base::base::seq(-500., 500., .1, data);
std::vector<double> y;
std::transform(data.begin(), data.end(), std::back_inserter(y), static_cast<double(*)(double)>(sin) );
std::vector<double> filt3(21,1./21.); // mean filter
double sumfilt = std::accumulate(filt3.begin(), filt3.end(), 0.0 );
ASSERT_NEAR(sumfilt, 1.0,epsilon );
std::vector<double> result;
ralab::base::filter::filter(
y,
filt3,
result
);
ralab::base::filter::filter(
y,
filt3,
result,
true
);
result.resize(y.size());
ralab::base::filter::filter_sequence(
y.begin(),
y.end(),
filt3.begin(),
filt3.size(),
result.begin(),
true
);
}
/*! \brief Evaluate data extension */
TEST_F( FilterUtilsTest,testExtendData)
{
std::vector<int> tmp, res;
ralab::base::base::seq(5,tmp);
std::vector<int>::iterator it = ralab::base::filter::utilities::prepareData(tmp.begin(),tmp.end(), 5, res);
res.resize(std::distance(res.begin(),it));
double ref[] = { 4, 5, 1, 2, 3, 4 ,5, 1, 2};
/*std::copy(res.begin(),res.end(),std::ostream_iterator<int>(std::cout," "));
std::cout << std::endl;
*/
bool iseq = std::equal(res.begin(),res.end(),ref);
ASSERT_TRUE(iseq);
it = ralab::base::filter::utilities::prepareData(tmp.begin(),tmp.end(), 5, res, true);
res.resize(std::distance(res.begin(),it));
double ref2[] = {2, 1, 1, 2, 3, 4, 5, 5, 4};
iseq = std::equal(res.begin(),res.end(),ref2);
ASSERT_TRUE(iseq);
}
}//end namespace
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| [
"wewolski@gmail.com"
] | wewolski@gmail.com |
0375809e82c3e2add6cf75956d050f006c40f358 | 9e1fb87d6aa5084c850d3165ea749da67d0add59 | /codeforces/435_C_DIV2_CODEFORCES.cpp | 1f9ce8ae0357ac75497acf19229e33a57a75bb27 | [] | no_license | Yang-33/competitive-programming | 673d57bc95efb559f8e2905bad758cd576505761 | f85ef9f1a5763334e4d26f9206154e4f7c0a85ac | refs/heads/master | 2021-01-12T03:19:17.961860 | 2019-10-06T15:35:48 | 2019-10-06T15:35:48 | 78,174,818 | 3 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 1,316 | cpp | #include "bits/stdc++.h"
using namespace std;
using VS = vector<string>; using LL = long long;
using VI = vector<int>; using VVI = vector<VI>;
using PII = pair<int, int>; using PLL = pair<LL, LL>;
using VL = vector<LL>; using VVL = vector<VL>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)
#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)
#define debug(x) cerr << #x << ": " << x << endl
const int INF = 1e9; const LL LINF = 1e16;
const LL MOD = 1000000007; const double PI = acos(-1.0);
int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 }; int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };
/* ----- 2017/09/19 Problem: CodeForces435 C div2 / Link: http:codeforces.com/contest/862/problem/C ----- */
/* ------問題------
-----問題ここまで----- */
/* -----解説等-----
----解説ここまで---- */
LL N;
LL ans = 0LL;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> N;
cout << ans << "\n";
return 0;
} | [
"kasai.yuta0810@gmail.com"
] | kasai.yuta0810@gmail.com |
6e31c2dfa420711f67d1bdb310d8d21b7468109d | 888b8f657b27712fcbd2d6df295c1d4aed4e4307 | /PAT/A1156 SexyPrimes.cpp | d6efe0c2839772c68dfa65962bc5f356d05d1d52 | [] | no_license | zzwblog/AlgorithmCode | 9a0b1fb0b459dad1c6d127cf1f1d996a97c2bac2 | 0e9c2f0b096298eaedf442674416d01afceac7a3 | refs/heads/master | 2022-12-15T16:09:04.009443 | 2020-09-03T10:48:53 | 2020-09-03T10:48:53 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 800 | cpp | //#include <iostream>
//using namespace std;
//bool isPrime(int x)//判断是不是素数
//{
// if (x < 3)
// return x >= 1;
// for (int i = 2; i*i <= x; ++i)
// if (x%i == 0)
// return false;
// return true;
//}
//int isSexyPrimes(int x)//判断满不满足题目要求
//{
// if (isPrime(x))
// {
// bool fL = isPrime(x - 6), fR = isPrime(x + 6);
// if (fL || fR)
// return fL ? x - 6 : x + 6;
// }
// return -1;
//}
//int main()
//{
// int n;
// cin >> n;
// int res = isSexyPrimes(n);
// if (res > 0)
// {
// printf("Yes\n");
// printf("%d\n", res);
// }
// else
// {
// printf("No\n");
// for (int i = n + 1; i < INT32_MAX; ++i)//另寻找大数，直至满足要求
// {
// if (isSexyPrimes(i) > 0)
// {
// printf("%d\n", i);
// break;
// }
// }
// }
// return 0;
//} | [
"819342493@qq.com"
] | 819342493@qq.com |
80d6a623acd443c9cf7ac494b09a3db624a68c44 | 0f08276e557de8437759659970efc829a9cbc669 | /problems/p625.h | 96c13d559ef66130c40de10bd2729dd302d73579 | [] | no_license | petru-d/leetcode-solutions-reboot | 4fb35a58435f18934b9fe7931e01dabcc9d05186 | 680dc63d24df4c0cc58fcad429135e90f7dfe8bd | refs/heads/master | 2023-06-14T21:58:53.553870 | 2021-07-11T20:41:57 | 2021-07-11T20:41:57 | 250,795,996 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 65 | h | #pragma once
namespace p625
{
class Solution
{
};
}
| [
"berserk.ro@gmail.com"
] | berserk.ro@gmail.com |
08aea5b7d79a266626fc2c3814bcbb87f05bf006 | 98157b3124db71ca0ffe4e77060f25503aa7617f | /tlx/tmoc-bnpchs-2021-final/h.cpp | e718562ac962dcd84bce01107792ffa536b08eb1 | [] | no_license | wiwitrifai/competitive-programming | c4130004cd32ae857a7a1e8d670484e236073741 | f4b0044182f1d9280841c01e7eca4ad882875bca | refs/heads/master | 2022-10-24T05:31:46.176752 | 2022-09-02T07:08:05 | 2022-09-02T07:08:35 | 59,357,984 | 37 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 5,074 | cpp | #include <bits/stdc++.h>
using namespace std;
struct SegTree {
int n;
vector<long long> sum;
vector<long long> unlocked_sum;
vector<int> unlocked_cnt;
vector<int> lazy, lock;
SegTree(int _n, const vector<int>& a) : n(_n), sum(2 * n), unlocked_sum(2 * n, 0), unlocked_cnt(2 * n, 0), lazy(2 * n, 0), lock(2 * n, 1) {
build(a, 0, 0, n);
}
void upd(int id, int v) {
if (lock[id] == 2) return;
if (v == 0) return;
sum[id] -= unlocked_sum[id];
unlocked_sum[id] = 1LL * v * unlocked_cnt[id];
sum[id] += unlocked_sum[id];
lazy[id] = v;
}
void combine(int id, int il, int ir, int l, int r) {
sum[id] = sum[il] + sum[ir];
unlocked_sum[id] = unlocked_sum[il] + unlocked_sum[ir];
unlocked_cnt[id] = unlocked_cnt[il] + unlocked_cnt[ir];
if (lock[id] == 2) {
unlocked_cnt[id] = 0;
unlocked_sum[id] = 0;
}
}
void pushdown(int id, int il, int ir) {
upd(il, lazy[id]);
upd(ir, lazy[id]);
lazy[id] = 0;
}
void build(const vector<int>& a, int id, int l, int r) {
lazy[id] = 0;
lock[id] = 1;
if (r-l < 2) {
sum[id] = a[l];
unlocked_sum[id] = a[l];
unlocked_cnt[id] = 1;
return;
}
int mid = (l+r) >> 1, il = id + 1, ir = id + (mid-l) * 2;
build(a, il, l, mid);
build(a, ir, mid, r);
combine(id, il, ir, l, r);
}
void update(int x, int y, int v, int id, int l, int r) {
if (x >= r || l >= y || lock[id] == 2) return;
if (x <= l && r <= y) {
if (r-l >= 2) {
int mid = (l+r) >> 1, il = id + 1, ir = id + (mid-l) * 2;
pushdown(id, il, ir);
}
upd(id, v);
return;
}
int mid = (l+r) >> 1, il = id + 1, ir = id + (mid-l) * 2;
pushdown(id, il, ir);
update(x, y, v, il, l, mid);
update(x, y, v, ir, mid, r);
combine(id, il, ir, l, r);
}
void update(int x, int y, int v) {
update(x, y, v, 0, 0, n);
}
void set_lock(int x, int y, int v, int id, int l, int r) {
if (x >= r || l >= y) return;
if (x <= l && r <= y) {
if (r-l >= 2) {
int mid = (l+r) >> 1, il = id + 1, ir = id + (mid-l) * 2;
pushdown(id, il, ir);
}
if (v == 2) {
assert(lock[id] == 1);
assert(unlocked_cnt[id] == r-l);
unlocked_cnt[id] = 0;
unlocked_sum[id] = 0;
} else {
assert(lock[id] == 2);
assert(v == 1);
assert(unlocked_cnt[id] == 0);
unlocked_cnt[id] = r-l;
unlocked_sum[id] = sum[id];
}
lock[id] = v;
return;
}
int mid = (l+r) >> 1, il = id + 1, ir = id + (mid-l) * 2;
pushdown(id, il, ir);
set_lock(x, y, v, il, l, mid);
set_lock(x, y, v, ir, mid, r);
combine(id, il, ir, l, r);
}
void set_lock(int x, int y, int v) {
set_lock(x, y, v, 0, 0, n);
}
long long get(int x, int y, int id, int l, int r) {
if (x >= r || l >= y) return 0;
if (x <= l && r <= y) {
return sum[id];
}
int mid = (l+r) >> 1, il = id + 1, ir = id + (mid-l) * 2;
pushdown(id, il, ir);
long long ret = get(x, y, il, l, mid);
ret += get(x, y, ir, mid, r);
return ret;
}
long long get(int x, int y) {
return get(x, y, 0, 0, n);
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(n+m, 0);
for (int i = 0; i < n; ++i)
cin >> a[i];
SegTree tree(n + m, a);
set<pair<int, int>> locked;
vector<pair<int, int>> to_delete;
auto find_ranges = [&](int l, int r) {
to_delete.clear();
auto it = locked.lower_bound(make_pair(l, -1));
while (it != locked.begin()) {
auto pre = it;
--pre;
if (pre->second >= l) {
it = pre;
} else {
break;
}
}
while (it != locked.end()) {
if (it->first <= r) {
to_delete.push_back(*it);
auto nxt = it;
++nxt;
tree.set_lock(it->first, it->second, 1);
locked.erase(it);
it = nxt;
} else {
break;
}
}
};
for (int i = 0; i < m; ++i) {
char op;
int l, r, v;
cin >> op;
if (op == 'F') {
cin >> l >> r >> v;
--l;
tree.update(l, r, v);
} else if (op == 'I') {
cin >> v;
tree.update(n, n+1, v);
++n;
} else if (op == 'L') {
cin >> l >> r;
--l;
find_ranges(l, r);
for (auto it : to_delete) {
l = min(l, it.first);
r = max(r, it.second);
}
tree.set_lock(l, r, 2);
locked.insert(make_pair(l, r));
} else if (op == 'C') {
cin >> l >> r;
--l;
find_ranges(l, r);
int lef = l, rig = r;
for (auto it : to_delete) {
lef = min(lef, it.first);
rig = max(rig, it.second);
}
if (lef < l) {
tree.set_lock(lef, l, 2);
locked.insert(make_pair(lef, l));
}
if (r < rig) {
tree.set_lock(r, rig, 2);
locked.insert(make_pair(r, rig));
}
} else {
cin >> l >> r;
--l;
cout << tree.get(l, r) << '\n';
}
}
return 0;
}
| [
"wiwitrifai@gmail.com"
] | wiwitrifai@gmail.com |
01fab5b8ac0d2e948183dbd7427697324387f073 | d884beed789e702aa3fa75cfd3abb694f07e6f66 | /Salt.cpp | 2439a373bcf22c2a6b25ddd55fb467825a5247a2 | [] | no_license | AnkitSiva/Salt-Analysis | 03daba8f7c4d4b2732c35b326369f685c2807564 | b5275e610d6610b78b4af7830954aed4b72df032 | refs/heads/master | 2016-09-01T11:56:07.809209 | 2016-02-09T06:14:46 | 2016-02-09T06:15:19 | 44,463,210 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 23,256 | cpp | #include <iostream>
#include <conio.h>
#include <stdio.h>
#include <fstream>
#include <process.h>
#include <iomanip>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <time.h>
#include <process.h>
using namespace std;
int a = 0;
struct Chemical
{
char reagVal[50];
Chemical *link;
/*
Holds integer value correlating to const value for specific reagent
*/
};
class Salt
{
private:
static int n_Anion;
static int n_Cation;
public:
static char CATION[12][20];
static char ANION[11][10];
static int GenerateRandomAnion();
static int GenerateRandomCation();
static char* getAnion(int);
static char* getCation(int);
/*
1. Abstract class
2. Stores all cation and anions
*/
};
char Salt::CATION[12][20] = {"Aluminium","Ammonium","Barium","Calcium","Copper","Ferric","Lead","Magnesium","Manganese","Nickel","Strontium","Zinc"};
char Salt::ANION[11][10] = {"Nitrate","Phosphate","Acetate","Bromide","Chloride","Sulphate","Oxalate","Carbonate","Iodide","Sulphide","Sulphite"};
char* Salt::getAnion(int ANIONS)
{
return ANION[ANIONS];
}
char* Salt::getCation(int CATIONS)
{
return CATION[CATIONS];
}
int Salt::GenerateRandomAnion()
{
srand(time(NULL));
return rand() % (n_Anion);
}
int Salt::GenerateRandomCation()
{
srand(time(NULL));
return rand() % (n_Cation);
}
int Salt::n_Cation = 12;
int Salt::n_Anion = 10;
class ReagentQueue : public Salt
{
private:
char ctr[10];
Chemical *rear;
Chemical *rev;
Chemical *link;
public:
int num;
Chemical *front;
Chemical *trav;
ReagentQueue()
{
front = NULL;
rear = NULL;
trav = NULL;
num = 0;
}
void add();
Chemical* getFront();
void add(char[][100], int);
void del();
void ClearQueue();
char* traverse();
void display(Chemical *a);
/*
1. Consists of general implementation of linked list queue with operations such as add, delete and traverse.
2. It is used to hold a list of type 'Chemical' which serves as a list of reagents.
*/
};
Chemical* ReagentQueue::getFront()
{
return front;
}
void input(Chemical *a)
{
cout<<"Enter data (chemical formula or name [eg: Copper Turnings], as specified in manual): ";
cin.ignore();
cin.getline(a->reagVal, 50, '\n');
cout<<'\n';
}
void ReagentQueue::add()
{
Chemical *np = new Chemical();
if(np==NULL)
{
cout<<"No memory";
exit(0);
}
np->link=NULL;
input(np);
if(front==NULL)
{
front = np;
rear = np;
trav = np;
}
else
{
rear->link=np;
rear=np;
}
cout << "Reagent has been added!";
num++;
}
void ReagentQueue::add(char Reag[][100], int n = 1)
{
for(int i = 0; i < n; i++)
{
Chemical *np = new Chemical();
if(np==NULL)
{
cout<<"No memory";
exit(0);
}
np->link=NULL;
strcpy(np->reagVal, Reag[i]);
if(front==NULL)
{
front=np;
rear=np;
trav = np;
}
else
{
rear->link=np;
rear=np;
}
num++;
}
}
void ReagentQueue::del()
{
Chemical *temp = front;
if(front == rear)
front = rear = NULL;
else
front = front -> link;
delete temp;
}
char* ReagentQueue::traverse()
{
return trav -> reagVal;
trav = trav -> link;
}
void ReagentQueue::display(Chemical *a)
{
cout<<a->reagVal<<" ";
}
void ReagentQueue::ClearQueue()
{
while(front != NULL)
{
del();
}
}
int CompareReagent(ReagentQueue userQ, ReagentQueue testQ)
{
int i = 0;
int count = 0;
char* userQVal = "empty";
char* testQVal = "empty";
int flag = 0;
if(userQ.num == testQ.num)
{
count = userQ.num;
Chemical* np1 = NULL;
Chemical* np2 = NULL;
np1 = testQ.getFront();
np2 = userQ.getFront();
while(np1 != NULL)
{
(testQVal = np1 -> reagVal);
(userQVal = np2 -> reagVal);
if(strcmp(testQVal, userQVal) != 0)
{
flag = 1;
break;
}
np1 = np1 -> link;
np2 = np2 -> link;
}
if (flag == 1)
return 0;
else
return 1;
}
else
return 0;
}
class UserModel
{
public:
ReagentQueue curr;
int ANION, CATION;
char observations[100][100];
int a;
UserModel()
{
generate();
a = 0;
}
void generate();
void addReagent();
void viewQueue();
void removeReagent();
void displaySalt();
};
void UserModel::generate()
{
ANION = Salt::GenerateRandomAnion();
CATION = Salt::GenerateRandomCation();
}
void UserModel::addReagent()
{
curr.add();
}
void UserModel::removeReagent()
{
curr.del();
}
void UserModel::viewQueue()
{
Chemical *np = new Chemical();
np = curr.getFront();
while(np != NULL)
{
curr.display(np);
np = np->link;
}
}
void UserModel::displaySalt()
{
system("cls");
cout<<"Salt:\nAnion: "<<Salt::getAnion(ANION)<<"\nCation: "<<Salt::getCation(CATION)<<'\n';
getch();
}
void prelims(UserModel &VirtUser)
{
cout<<"Execute preliminary tests\n";
if((VirtUser.CATION + 1)==5||(VirtUser.CATION + 1)==6||(VirtUser.CATION + 1)==9||(VirtUser.CATION + 1)==10)
{
if((VirtUser.CATION + 1)==5)
strcpy(VirtUser.observations[VirtUser.a++],"Colour: Blue");
else if((VirtUser.CATION + 1)==6)
strcpy(VirtUser.observations[VirtUser.a++],"Colour: Brown");
else if((VirtUser.CATION + 1)==9)
strcpy(VirtUser.observations[VirtUser.a++],"Colour: Pink");
else if((VirtUser.CATION + 1)==10)
strcpy(VirtUser.observations[VirtUser.a++],"Colour: Green");
}
else
strcpy(VirtUser.observations[VirtUser.a++],"Colourless");
if((VirtUser.CATION + 1)==2||(VirtUser.ANION + 1) ==3||(VirtUser.ANION + 1) ==10)
{
if((VirtUser.CATION + 1)==2)
strcpy(VirtUser.observations[VirtUser.a++],"Smell: Ammonical");
else if((VirtUser.ANION + 1) ==3)
strcpy(VirtUser.observations[VirtUser.a++],"Smell: Vinegar");
else if((VirtUser.ANION + 1) ==10)
strcpy(VirtUser.observations[VirtUser.a++],"Smell: Rotten Eggs");
}
else
strcpy(VirtUser.observations[VirtUser.a++],"Odourless");
if(!(VirtUser.CATION + 1)==7)
{
if(!(VirtUser.CATION + 1)==7)
{
strcpy(VirtUser.observations[VirtUser.a++],"Insoluble in Water");
strcpy(VirtUser.observations[VirtUser.a++],"Insoluble in HCL");
}
}
else
{
strcpy(VirtUser.observations[VirtUser.a++],"Soluble in Water");
strcpy(VirtUser.observations[VirtUser.a++],"Soluble in HCl");
}
if((VirtUser.CATION + 1)==3||(VirtUser.CATION + 1)==4||(VirtUser.CATION + 1)==5||(VirtUser.CATION + 1)==6||(VirtUser.CATION + 1)==11)
{
if((VirtUser.CATION + 1)==3)
strcpy(VirtUser.observations[VirtUser.a++],"Apple Green Flame");
else if((VirtUser.CATION + 1)==4)
strcpy(VirtUser.observations[VirtUser.a++],"Brick Red Flame");
else if((VirtUser.CATION + 1)==5)
strcpy(VirtUser.observations[VirtUser.a++],"Blue Green Flame");
else if((VirtUser.CATION + 1)==11)
strcpy(VirtUser.observations[VirtUser.a++],"Crimson Red Flame");
}
else
strcpy(VirtUser.observations[VirtUser.a++],"No Characteristic flame");
}
void DilAcid(UserModel &VirtUser)
{
cout<<"Execute Dilute Acid Test\n";
if((VirtUser.ANION + 1) ==6||(VirtUser.ANION + 1) ==8||(VirtUser.ANION + 1) ==10)
{
if((VirtUser.ANION + 1) ==6)
strcpy(VirtUser.observations[VirtUser.a++],"Colourless gas,smell like that of burning sulphur,turns acidified pot dichromate paper green.");
else if((VirtUser.ANION + 1) ==8)
strcpy(VirtUser.observations[VirtUser.a++],"Brisk effervescence is noted.A colourless odourless gas turning lime water milky is evolved.");
else if((VirtUser.ANION + 1) ==10)
strcpy(VirtUser.observations[VirtUser.a++],"Colourless gas with the smell of rotten eggs.Turns lead acetate paper black.");
}
else
strcpy(VirtUser.observations[VirtUser.a++],"Absence of Carbonate,Sulphide,Sulphate ions");
}
void ConcAcid(UserModel &VirtUser)
{
cout<<"Execute Conc Acid Test\n";
if((VirtUser.ANION + 1) ==1||(VirtUser.ANION + 1) ==3||(VirtUser.ANION + 1) ==4||(VirtUser.ANION + 1) ==5||(VirtUser.ANION + 1) ==7||(VirtUser.ANION + 1) ==9)
{
if((VirtUser.ANION + 1) ==1)
strcpy(VirtUser.observations[VirtUser.a++],"Slight brown fumes turning FeSO4 solution black");
else if((VirtUser.ANION + 1) ==3)
strcpy(VirtUser.observations[VirtUser.a++],"Colourless gas with a smell of vinegar which turns moist blue litmus paper red is evolved");
else if((VirtUser.ANION + 1) ==4)
strcpy(VirtUser.observations[VirtUser.a++],"Reddish brown gas which turns moist starch Iodide paper blue");
else if((VirtUser.ANION + 1) ==5)
strcpy(VirtUser.observations[VirtUser.a++],"Colourless gas with a irritating smell which gives dense white fumes when a glass rod dipped in Ammonium Hydroxide is introduced");
else if((VirtUser.ANION + 1) ==7)
strcpy(VirtUser.observations[VirtUser.a++],"Colourless gas which turns lime water milky");
else if((VirtUser.ANION + 1) ==9)
strcpy(VirtUser.observations[VirtUser.a++],"Violet vapours which turn moist starch paper blue black");
}
else
strcpy(VirtUser.observations[VirtUser.a++],"Absence of Chloride,Bromide,Iodide,Oxalate,Nitrate,Acetate ions");
}
void ConfirmAcidRadical(UserModel &VirtUser)
{
ReagentQueue reag = ReagentQueue();
cout<<"Execute Confirmatory Tests For Acid Radical\n";
if((VirtUser.ANION + 1) ==1||(VirtUser.ANION + 1) ==2||(VirtUser.ANION + 1) ==3||(VirtUser.ANION + 1) ==4||(VirtUser.ANION + 1) ==5||(VirtUser.ANION + 1) ==6||(VirtUser.ANION + 1) ==7||(VirtUser.ANION + 1) ==9||(VirtUser.ANION + 1) ==10||(VirtUser.ANION + 1) ==11)
{
if((VirtUser.ANION + 1) == 1)
{
reag.ClearQueue();
reag.add(new char[2][100]{"H2SO4","Copper Turnings"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"The solution turns green and there is profuse evolution of brown fumes which turn FeSO4 sol black");
reag.ClearQueue();
reag.add(new char[2][100]{"H2SO4","Paper Pellets"}, 2);
if(CompareReagent(VirtUser.curr, reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Profuse evolution of brown fumes which turn FeSO4 sol black");
reag.ClearQueue();
reag.add(new char[2][100]{"FeSO4","Conc H2SO4"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"A brown ring is formed at the junction of two liquids");
}
else if((VirtUser.ANION + 1) ==2)
{
reag.ClearQueue();
reag.add(new char[2][100]{"Conc HNO3","Ammonium Molybdate"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Canary yellow ppt is formed");
reag.ClearQueue();
reag.add(new char[1][100]{"Magnesia Mixture"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"White ppt is obtained");
}
else if((VirtUser.ANION + 1) ==3)
{
reag.ClearQueue();
reag.add(new char[2][100]{"Conc H2SO4","C2H5OH"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"A pleasent fruity smell of ester is got");
reag.ClearQueue();
reag.add(new char[1][100]{"Neutral FeCl3"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Red colour is formed");
}
else if((VirtUser.ANION + 1) ==4)
{
reag.ClearQueue();
reag.add(new char[2][100]{"MnO2","H2SO4"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Reddish brown vapours turning moist starch paper yellow and moist starch iodide paper blue is evolved");
reag.ClearQueue();
reag.add(new char[2][100]{"Chlorine Water","CCl4"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Orange brown organic layer is formed");
reag.ClearQueue();
reag.add(new char[1][100]{"AgNO3"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Straw coloured ppt formed which is partly soluble in NH4OH");
}
else if((VirtUser.ANION + 1) ==5)
{
reag.ClearQueue();
reag.add(new char[4][100]{"Potassium Dichromate","Conc H2SO4","CH3COOH","(CH3COO)2Pb"}, 4);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Yellow ppt is obtained");
reag.ClearQueue();
reag.add(new char[1][100]{"AgNO3"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Curdy white ppt fully soluble in excess of NH4OH");
reag.ClearQueue();
reag.add(new char[2][100]{"MnO2","Conc H2SO4"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Greenish yellow gas is evolved");
}
else if((VirtUser.ANION + 1) ==6)
{
reag.ClearQueue();
reag.add(new char[1][100]{"BaCl2"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"A white ppt insoluble in conc HCL is obtained");
reag.ClearQueue();
reag.add(new char[2][100]{"CH3COOH","(CH3COO)2Pb"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"White ppt soluble in excess of (CH3COO)NH4 is formed");
}
else if((VirtUser.ANION + 1) ==7)
{
reag.ClearQueue();
reag.add(new char[2][100]{"CH3COOH","CaCl2"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"White ppt is obtained");
reag.ClearQueue();
reag.add(new char[2][100]{"Dil H2SO4","KMnO4"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Pink colour of KMnO4 is decolourised and CO2 is evolved");
}
else if((VirtUser.ANION + 1) ==9)
{
reag.ClearQueue();
reag.add(new char[2][100]{"MnO2","H2SO4"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Violet vapours which turn moist starch paper blue is obtained");
reag.ClearQueue();
reag.add(new char[2][100]{"Chlorine Water","CCl4"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Pink organic layer is obtained");
reag.ClearQueue();
reag.add(new char[1][100]{"AgNO3"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Yellow ppt completely insoluble in NH4OH is got");
}
else if((VirtUser.ANION + 1) ==10)
{
reag.ClearQueue();
reag.add(new char[2][100]{"CH3COOH","(CH3COO)2Pb"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Black ppt is formed");
reag.ClearQueue();
reag.add(new char[1][100]{"Sodium Nitroprusside"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Purple colour is obtained");
}
else if((VirtUser.ANION + 1) ==11)
{
reag.ClearQueue();
reag.add(new char[1][100]{"BaCl2"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"White ppt is obtained");
reag.ClearQueue();
reag.add(new char[2][100]{"K2Cr2O7","Dil H2SO4"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Green colourisation is obtained");
}
}
else
strcpy(VirtUser.observations[VirtUser.a++],"Absence of Anion! Tests Done Wrong.");
}
void ConfirmBasicRadical(UserModel &VirtUser)
{
ReagentQueue reag = ReagentQueue();
if((VirtUser.CATION + 1)==2)
{
if((VirtUser.CATION + 1)==2)
{
reag.ClearQueue();
reag.add(new char[1][100]{"NaOH"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Colourless gas with a pungent smell giving dense white fumes with a rod dipped in conc HCL");
reag.ClearQueue();
reag.add(new char[2][100]{"NaOH","Nesslers Reagent"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Red brown ppt is formed");
}
else
strcpy(VirtUser.observations[VirtUser.a++],"Absence of Zero group!");
}
if((VirtUser.CATION + 1)==1||(VirtUser.CATION + 1)==3||(VirtUser.CATION + 1)==4||(VirtUser.CATION + 1)==5||(VirtUser.CATION + 1)==6||(VirtUser.CATION + 1)==7||(VirtUser.CATION + 1)==8||(VirtUser.CATION + 1)==9||(VirtUser.CATION + 1)==10||(VirtUser.CATION + 1)==11||(VirtUser.CATION + 1)==12)
{
if((VirtUser.CATION + 1)==1)
{
reag.ClearQueue();
reag.add(new char[1][100]{"NaOH"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Gelatinous white ppt is obtained");
reag.ClearQueue();
reag.add(new char[2][100]{"Blue litmus","NH4OH"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Blue lake is formed");
}
else if((VirtUser.CATION + 1)==3)
{
reag.ClearQueue();
reag.add(new char[1][100]{"K2CrO4"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Yellow ppt is obtained");
}
else if((VirtUser.CATION + 1)==4)
{
reag.ClearQueue();
reag.add(new char[1][100]{"(NH4)2C2O49"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"White ppt is obtained");
}
else if((VirtUser.CATION + 1)==5)
{
reag.ClearQueue();
reag.add(new char[1][100]{"NH4OH"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"A light blue ppt dissolving in excess to give a deep blue solution");
reag.ClearQueue();
reag.add(new char[1][100]{"K4[Fe(CN)6]"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Chocolate brown ppt is formed");
}
else if((VirtUser.CATION + 1)==6)
{
reag.ClearQueue();
reag.add(new char[1][100]{"K4[Fe(CN)6]"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Prussian blue colour is formed");
reag.ClearQueue();
reag.add(new char[2][100]{"Dil HCL","KCNS"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Blood red colour is formed");
}
else if((VirtUser.CATION + 1)==7)
{
reag.ClearQueue();
reag.add(new char[1][100]{"K2CrO4"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Yellow ppt is obtained");
reag.ClearQueue();
reag.add(new char[1][100]{"KI"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Yellow ppt which is soluble when heated and reappears as golden spangles");
reag.ClearQueue();
reag.add(new char[1][100]{"H2SO4"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"White ppt soluble in (CH3COO)NH4");
}
else if((VirtUser.CATION + 1)==8)
{
reag.ClearQueue();
reag.add(new char[3][100]{"NH4Cl","NH4OH","Na2HPO4"}, 3);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"White ppt is obtained");
reag.ClearQueue();
reag.add(new char[4][100]{"NH4Cl","NH4OH","Na2HPO4","CO(NO3)2"}, 4);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Pink ash is obtained");
}
else if((VirtUser.CATION + 1)==9)
{
reag.ClearQueue();
reag.add(new char[1][100]{"NaOH"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"A white ppt which turns brown and finally black on long standing");
reag.ClearQueue();
reag.add(new char[2][100]{"Conc HNO3","PbO2"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Pinkish purple colour is obtained");
}
else if((VirtUser.CATION + 1)==10)
{
reag.ClearQueue();
reag.add(new char[1][100]{"NaOH"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Apple green ppt is formed");
reag.ClearQueue();
reag.add(new char[2][100]{"Dimethyl glyoxime","NH4OH"}, 2);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Cherry red ppt is formed");
}
else if((VirtUser.CATION + 1)==11)
{
reag.ClearQueue();
reag.add(new char[1][100]{"(NH4)2SO4"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"White ppt is formed");
}
else if((VirtUser.CATION + 1)==12)
{
reag.ClearQueue();
reag.add(new char[1][100]{"NaOH"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"A white ppt soluble in excess is obtained");
reag.ClearQueue();
reag.add(new char[1][100]{"K4[Fe(CN)6]"}, 1);
if(CompareReagent(VirtUser.curr,reag) == 1)
strcpy(VirtUser.observations[VirtUser.a++],"Greenish white ppt is formed");
}
}
else
strcpy(VirtUser.observations[VirtUser.a++],"Absence of Cation! Tests Done Wrong");
}
void execute(UserModel &VirtUser)
{
ConfirmAcidRadical(VirtUser);
ConfirmBasicRadical(VirtUser);
}
void displayAbout()
{
char t[80];
ifstream fi("About.txt");
if(!fi)
{
cout<<"File open error";
return;
}
while(!fi.eof())
{
fi.getline(t,80);
cout<<t<<endl;
}
fi.close();
cout<<"\n\nHit any key to continue...";
getch();
}
void DisplayUI(UserModel &user)
{
system("cls");
cout<<"-------------------------------------------------------------------------------\n";
cout<<"\t\t\t Salt Anaysis Simulator 1.0\n";
cout<<"-------------------------------------------------------------------------------\n";
cout<<"Tests/Observations:\n\n";
for(int i = 0; i < user.a; i++)
cout<<(i + 1)<<". "<<user.observations[i]<<"\n";
cout<<"-------------------------------------------------------------------------------\n\n";
cout<<"1. Add reagent to queue\n";
cout<<"2. Remove reagent from queue\n";
cout<<"3. View reagent queue\n";
cout<<"4. Run Prelims\n";
cout<<"5. Dilute Acid Test\n";
cout<<"6. Concentrated Acid Test\n";
cout<<"7. Execute test\n";
cout<<"8. View answer\n";
cout<<"9. About\n";
cout<<"10. Exit\n\n";
cout<<"Enter choice: ";
}
int main()
{
UserModel user = UserModel();
int choice = 0;
while(1 == 1)
{
DisplayUI(user);
cin>>choice;
switch(choice)
{
case 1:
user.addReagent();
getch();
break;
case 2:
user.removeReagent();
getch();
break;
case 3:
user.viewQueue();
getch();
break;
case 4:
prelims(user);
getch();
break;
case 5:
DilAcid(user);
getch();
break;
case 6:
ConcAcid(user);
getch();
break;
case 7:
execute(user);
getch();
break;
case 8:
user.displaySalt();
getch();
break;
case 9:
displayAbout();
getch();
break;
case 10:
exit(0);
break;
default:
cout<<"Please enter a valid choice!\n";
}
}
return 0;
}
| [
"ankitsiva@outlook.com"
] | ankitsiva@outlook.com |
0f4892a3def69f1dfb4d81ac829db1ff3e8c8a5f | 0b645646cb2de4ec0619e5aa6178e96b791f3bb8 | /tests/auto/qtpromise/helpers/attempt/tst_attempt.cpp | 87b9ff37bbb7b3173473ce52ec7142ec748860c9 | [
"MIT"
] | permissive | yssource/qtpromise | 28752fa9bf8de6e3bfa9414f706dda80ffbf5d2e | 1f30224578136434055783906f6224003bf8b82d | refs/heads/master | 2020-04-30T06:54:20.392756 | 2019-03-04T12:58:01 | 2019-03-04T13:02:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,334 | cpp | #include "../../shared/utils.h"
// QtPromise
#include <QtPromise>
// Qt
#include <QtConcurrent>
#include <QtTest>
// STL
#include <memory>
using namespace QtPromise;
class tst_helpers_attempt : public QObject
{
Q_OBJECT
private Q_SLOTS:
void voidResult();
void typedResult();
void futureResult();
void promiseResult();
void functorThrows();
void callWithParams();
};
QTEST_MAIN(tst_helpers_attempt)
#include "tst_attempt.moc"
void tst_helpers_attempt::voidResult()
{
auto p = QtPromise::attempt([]() {});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForValue(p, -1, 42), 42);
}
void tst_helpers_attempt::typedResult()
{
auto p = QtPromise::attempt([]() {
return QString("foo");
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QString>>::value));
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForValue(p, QString()), QString("foo"));
}
void tst_helpers_attempt::futureResult()
{
auto p = QtPromise::attempt([]() {
return QtConcurrent::run([]() {
return QString("foo");
});
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QString>>::value));
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, QString()), QString("foo"));
}
void tst_helpers_attempt::promiseResult()
{
auto p = QtPromise::attempt([]() {
return QtPromise::qPromise(42).delay(200);
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<int>>::value));
QCOMPARE(p.isPending(), true);
QCOMPARE(waitForValue(p, -1), 42);
}
void tst_helpers_attempt::functorThrows()
{
auto p = QtPromise::attempt([]() {
if (true) {
throw QString("bar");
}
return 42;
});
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<int>>::value));
QCOMPARE(p.isRejected(), true);
QCOMPARE(waitForError(p, QString()), QString("bar"));
}
void tst_helpers_attempt::callWithParams()
{
auto p = QtPromise::attempt([&](int i, const QString& s) {
return QString("%1:%2").arg(i).arg(s);
}, 42, "foo");
Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QString>>::value));
QCOMPARE(p.isFulfilled(), true);
QCOMPARE(waitForValue(p, QString()), QString("42:foo"));
}
| [
"simonbrunel@users.noreply.github.com"
] | simonbrunel@users.noreply.github.com |
63e4e2556f79bb7b5b5e4c71fcf12181c62efbd8 | 50c74a5dd38180e26f0608cb0002585489445555 | /Codeforces Solutions/863B.cpp | ed4fe8a8c0cc4e63a6b8309961d7de3064980170 | [] | no_license | ShobhitBehl/Competitive-Programming | 1518fe25001cc57095c1643cc8c904523b2ac2ef | 7a05897ca0ef5565655350803327f7f23bcf82fe | refs/heads/master | 2020-04-17T05:20:52.302129 | 2019-03-18T10:17:47 | 2019-03-18T10:17:47 | 166,265,289 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,622 | cpp | #include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stack>
#include <string>
#include <climits>
#include <queue>
using namespace std;
/*lli power(lli a,lli b)
{
lli ans;
while(b > 0)
{
if(b%2 == 1)
{
ans *= a;
}
b /=2;
a*=a;
}
return ans;
}*/
typedef long long int lli;
struct comparator {
bool operator()(lli i, lli j) {
return i > j;
}
};
lli gcd(lli a, lli b)
{
if(a == 0)
{
return b;
}
return gcd(b%a,a);
}
long long int min(long long int a, long long int b)
{
return a>b?b:a;
}
long long int max(long long int a, long long int b)
{
return a>b?a:b;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
lli n;
cin >> n;
lli a[2*n];
for(int i = 0; i<2*n; i++)
{
cin >> a[i];
}
sort(a,a+2*n);
lli ans = INT_MAX,temp = 0;
for(int i = 0; i<2*n; i++)
{
for(int j = i+1; j<2*n; j++)
{
temp = 0;
for(int k = 0; k<2*n; k++)
{
if(k == i || k == j)
{
continue;
}
else
{
int x = 1;
while(k+x == i || k+x == j)
{
x++;
}
temp += a[k+x] - a[k];
k+=x;
}
}
if(temp < ans)
{
ans = temp;
}
}
}
cout << ans << endl;
}
| [
"shobhitbehl1@gmail.com"
] | shobhitbehl1@gmail.com |
432a31378be193664503b9b4ab272b5e38aee8fd | 6005a14f4a1a243892138e52eb912c055c59c759 | /src/quick/nexus.h | 486a0cf12cc4869f439a0b4ca16e9e611cf9524a | [] | no_license | trinhvo/planet-renderer-1 | f452841ceed89122a02aa19663c1a5fd8b250673 | 50a214df753888bba810ad783f618eeeed7c1aab | refs/heads/master | 2020-08-15T16:13:10.303815 | 2016-03-05T07:17:59 | 2016-03-05T07:17:59 | 215,369,754 | 1 | 0 | null | 2019-10-15T18:31:56 | 2019-10-15T18:31:56 | null | UTF-8 | C++ | false | false | 358 | h | #ifndef NEXUS_H
#define NEXUS_H
#include <vector>
#include <QtGui/QSurfaceFormat>
#include <QtCore/QString>
class QThread;
class nexus {
public:
static QSurfaceFormat select_gl(QSurfaceFormat);
static QString get_scene_name();
static void register_thread(QThread*);
static void terminate();
private:
static std::vector<QThread*> threads_;
};
#endif
| [
"xinyazhang@utexas.edu"
] | xinyazhang@utexas.edu |
fec34047d13b7eacecc8a51546bf315f2b2f6f75 | c5e26167d000f9d52db0a1491c7995d0714f8714 | /白马湖OJ/1429.cpp | ba2e049b7ec3b2f8c5e4eb663a1ab1b22ecb6500 | [] | no_license | memset0/OI-Code | 48d0970685a62912409d75e1183080ec0c243e21 | 237e66d21520651a87764c385345e250f73b245c | refs/heads/master | 2020-03-24T21:23:04.692539 | 2019-01-05T12:38:28 | 2019-01-05T12:38:28 | 143,029,281 | 18 | 1 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 1,390 | cpp | #include <bits/stdc++.h>
#define max lala01
using namespace std;
int x, y, n;
double t, each, max, ans;
void DFS(double ua, double ub, int i_, int j_)
{
int k = ua * ub / each;
for (int i = 1; i <= i_; i++) printf(" ");
if (j_) printf("ºá "); else printf("×Ý ");
printf("ua = %.2lf; ub = %.2lf; k = %d max = %.2lf ans = %.2lf\n", ua, ub, k, max, ans);
if (k == 1)
{
//ÕÒµ½´ð°¸
if ()
if (max < ans) ans = max;
return;
}
//ºáÇÐ
for (int i = 1; 2 * i <= k; i++)
{
double max_back = max;
double va = ua * i / k, vb = ub;
if (va < vb) t = va, va = vb, vb = t;
if (va / vb > max) max = va / vb;
if (max <= ans) DFS(va, vb, i_+1, 1);
va = ua - va;
if (va <= vb) t = va, va = vb, vb = t;
if (va / vb > max) max = va / vb;
if (max <= ans) DFS(va, vb, i_+1, 1);
max = max_back;
}
//×ÝÇÐ
for (int i = 1; 2 * i <= k; i++)
{
double max_back = max;
double vb = ub * i / k, va = ua;
if (va < vb) t = va, va = vb, vb = t;
if (va / vb > max) max = va / vb;
if (max <= ans) DFS(va, vb, i_+1, 0);
vb = ub - vb;
if (va < vb) t = va, va = vb, vb = t;
if (va / vb > max) max = va / vb;
if (max <= ans) DFS(va, vb, i_+1, 0);
max = max_back;
}
}
int main()
{
scanf("%d%d%d", &x, &y, &n);
if (x < y) t = x, x = y, y = t;
each = x * y / (double)n;
max = x / y;
ans = x * y;
DFS(x, y, 0, 1);
printf("%.8lf", ans);
}
| [
"memset0@outlook.com"
] | memset0@outlook.com |
32a30973cd165bbbab5476c8622dd61f99b818a9 | 6fb323ee4ac39fc781c846dab87d74a558457c7f | /project/server/include/rsc/seccam/signaling_state.hpp | 702698e68777817e8ac7bdf415834578ed925e33 | [] | no_license | locatw/RaspSecCam | 7f6e50eb78eb088978910a0021ae2d8b6a735245 | bccf1bf713d5eab233bb831ede627145a98b1ab3 | refs/heads/master | 2021-01-20T10:37:28.633123 | 2014-11-29T12:03:47 | 2014-11-29T12:03:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 774 | hpp | #ifndef INC_RSC_SECCAM_SIGNALING_STATE_HPP
#define INC_RSC_SECCAM_SIGNALING_STATE_HPP
#include <memory>
#include <boost/optional.hpp>
#include "rsc/seccam/app_state.hpp"
#include "rsc/seccam/camera_format.hpp"
namespace rsc {
namespace seccam {
class camera;
class connector;
class signaling_state : public app_state
{
public:
signaling_state(
std::shared_ptr<camera>& camera,
std::shared_ptr<connector>& connector);
void on_entry() override;
private:
void write_camera_format(const camera_format& format);
void write_camera_width(size_t width);
void write_camera_height(size_t height);
void write_size(size_t size);
private:
std::shared_ptr<camera> camera_;
std::shared_ptr<connector>& connector_;
};
} // namespace seccam
} // namespace rsc
#endif
| [
"dummy@mail.com"
] | dummy@mail.com |
4205c096b42622a94eced495298a7a7ece50eae2 | 8f9c61c19e8999bc9d5bc14c55fe996f3a408dd4 | /src/JLinkage/JL.h | 51d5129d383ab890538a33ccddc1c46125e0a669 | [] | no_license | native93/ptam | 7d184f5791608ec5616a50b36d74b6004d6a3f8b | 3e4305c23f8cfea6717c1bd9cce2906c394c07f2 | refs/heads/master | 2016-09-06T09:14:03.078097 | 2015-05-03T22:05:19 | 2015-05-03T22:05:19 | 35,002,332 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,465 | h | #include "RandomSampler.h"
#include "JLinkage.h"
#include <ctime>
#include <cvd/thread.h>
#include "densify.h"
using namespace TooN;
struct dataPoint{
std::vector<float> *val;
MapPoint *mp;
int indX;
sPtLnk *clP;
int processed;
};
class JL : protected CVD::Thread{
public:
JL(Map *iMap, ATANCamera *iCam, int inSample, int isamplingType, float isamplingCoef, float iinlierThreshold, int iKdTreeRAnge, int minpts, double iKdTreeCloseProb = 1.0, double iKdTreeFarProb = 1.0 );
~JL();
virtual void run();
private:
//thread
/// COMMON
int padded;
Map *jMap;
ATANCamera *Cam;
int minPts;
std::vector<dataPoint*> mDataPoints; // Data Points
void add_points();
void update_point(dataPoint*);
void load_points();
void delete_point(dataPoint *dP, int i);
/// SAMPLE
int samplingType; //sampling type
int nSample; // no of samples
int mMSS; // PLANE
float samplingCoef; //sampling variables
double KdTreeCloseProb; // kdtree search
double KdTreeFarProb; // kdtree search
std::vector<std::vector<float> *> *sample();
densify denser;
RandomSampler mRandomSampler;
//// CLUSTER
int KdTreeRange; //clustering variable
int planepointsthresh; //min points in cluster
float inlierThreshold; //threshold for inliers
JLinkage mJLinkage;
/// HELPER FUNCTIONS
};
| [
"nazrul@nazrul-Vostro.(none)"
] | nazrul@nazrul-Vostro.(none) |
89d61b02cbb0a6a8ca3b9be16c29ca37502845e6 | 58436d83f4d516a01c36bfc6033748b5b665abc3 | /CSC-254/CSC254/A2/parser(Milestone10.1)/parse.cpp | 28f8c1ba905a9207a20a11d525567fdbc8ceb7b7 | [] | no_license | vchittar/CSC-254 | 3afde177d44e6170bc6a71aeb51f7a3bd81eac2b | 18263795ca7a9614e7630601cdd704c32617ccac | refs/heads/master | 2021-04-28T22:27:54.376639 | 2016-12-31T18:21:25 | 2016-12-31T18:21:25 | 77,751,430 | 1 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 15,478 | cpp | /* Complete recursive descent parser for the calculator language.
Builds on figure 2.16. Prints a trace of productions predicted and
tokens matched. Does no error recovery: prints "syntax error" and
dies on invalid input.
*/
#include <iostream>
//#include "stdlib.h"
#include <iterator>
#include <vector>
#include <algorithm>
#include "scan.hpp"
using namespace std;
const std::string names[] = {"read", "write", "if", "fi", "do", "od", "check", "id", "literal", "gets", "ro",
"eqv", "Not_Eqv", "smaller", "larger", "<=", ">=", "add", "sub", "mul", "div", "lparen", "rparen", "eof"};
static token input_token;
std::string output = "";
std::string idF = "", idFO = "";
void error () {
cout<< ("syntax error\n");
throw "You're screwed";
}
void match (token expected) {
if (input_token == expected) {
//cout << "matched " << names[input_token];
//if (input_token == t_id || input_token == t_literal)
// output += token_image;
//cout<< ("\n");
input_token = scan ();
}else if(input_token == t_eof){
cout << "ERROR - token not matched, and end of file is reached\n";
return;
}
else{
cout << "ERROR - token not matched. \n";
input_token = scan();
match(expected);
}
}
void program ();
void stmt_list ();
void stmt ();
void relation ();
void expr ();
void expr_tail ();
void term ();
void term_tail ();
void factor_tail ();
void factor ();
void add_op ();
void mul_op ();
void rel_op ();
token firstP[] = {t_id, t_read, t_write, t_if, t_do, t_check};
token firstSL[] = {t_eof, t_fi, t_od, t_id, t_read, t_write, t_if, t_do, t_check};
token firstS[] = {t_id, t_read, t_write, t_if, t_do, t_check};
token firstR[] = {t_lparen, t_id, t_literal};
token firstE[] = {t_lparen, t_id, t_literal};
token firstT[] = {t_lparen, t_id, t_literal};
token firstF[] = {t_lparen, t_id, t_literal};
token firstET[] = {t_eqv, t_ne, t_smaller, t_larger, t_es, t_el, t_rparen, t_id, t_read, t_write, t_if, t_do, t_check, t_eof};
token firstTT[] = {t_add, t_sub, t_eqv, t_ne, t_smaller, t_larger, t_es, t_el, t_rparen, t_id, t_read, t_write, t_if, t_do, t_check, t_eof};
token firstFT[] = {t_mul, t_div, t_add, t_sub, t_eqv, t_ne, t_smaller, t_larger, t_es, t_el, t_rparen, t_id, t_read, t_write, t_if, t_do, t_check, t_eof};
token firstAo[] = {t_add, t_sub};
token firstMo[] = {t_mul, t_div};
token firstRo[] = {t_eqv, t_ne, t_smaller, t_larger, t_es, t_el};
token followP[] = {};
token followSL[] = {t_eof, t_fi, t_od};
token followS[] = {t_eof, t_fi, t_od};
token followR[] = {t_eof, t_fi, t_od, t_rparen};
token followE[] = {t_eqv, t_ne, t_smaller, t_larger, t_es, t_el, t_eof, t_fi, t_od, t_rparen};
token followT[] = {t_add, t_sub, t_eqv, t_ne, t_smaller, t_larger, t_es, t_el, t_eof, t_fi, t_od, t_rparen};
token followF[] = {t_mul, t_div, t_add, t_sub, t_eqv, t_ne, t_smaller, t_larger, t_es, t_el, t_eof, t_fi, t_od, t_rparen};
token followET[] = {t_eof, t_fi, t_od, t_rparen};
token followTT[] = {t_eqv, t_ne, t_smaller, t_larger, t_es, t_el, t_eof, t_fi, t_od, t_rparen};
token followFT[] = {t_add, t_sub, t_eqv, t_ne, t_smaller, t_larger, t_es, t_el, t_eof, t_fi, t_od, t_rparen};
token followOp[] = {t_lparen, t_id, t_literal};
bool contains(token array[], token input, int size){
int i = 0;
while(i < size){
if(array[i] == input)
return true;
i++;
}
return false;
}
//P
void program () {
/*if (!(std::find(std::begin(firstP), std::end(firstP), input_token) != std::end(firstP) || std::find(std::begin(followP), std::end(followP), input_token) != std::end(followP))){
cout << "Screw you! You're stupid enough to not be able to write a working P!"
while (!(std::find(std::begin(firstP), std::end(firstP), input_token) != std::end(firstP) || std::find(std::begin(followP), std::end(followP), input_token) != std::end(followP) || input_token == t_eof)){
input_token = scan();
}
}*/
if(! (contains(firstP,input_token,sizeof(firstP)/4) || contains(followP, input_token,sizeof(followP)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstP,input_token,sizeof(firstP)/4) || contains(followP, input_token,sizeof(followP)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token) {
case t_id:
case t_read:
case t_write:
case t_if:
case t_do:
case t_check:
case t_eof:
cout<< ("predict program --> stmt_list eof\n");
stmt_list ();
match (t_eof);
break;
default:
//error ();
return;
}
}
//SL
void stmt_list () {
if(! (contains(firstSL,input_token,sizeof(firstSL)/4) || contains(followSL, input_token,sizeof(followSL)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstSL,input_token,sizeof(firstSL)/4) || contains(followSL, input_token,sizeof(followSL)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token) {
case t_id:
case t_read:
case t_write:
case t_if:
case t_do:
case t_check:
cout<< ("predict stmt_list --> stmt stmt_list\n");
stmt ();
//cout << "OUTPUT: "<<output;
stmt_list ();
break;
//case t_eof:
case t_fi:
case t_od:
cout << ("predict stmt_list --> epsilon\n");
break; /* epsilon production */
case t_eof:
cout << "OUTPUT: "<<output;
output = "";
break;
default: error ();
}
}
//S
void stmt () {
if(! (contains(firstS,input_token,sizeof(firstS)/4) || contains(followS, input_token,sizeof(followS)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstS,input_token,sizeof(firstS)/4) || contains(followS, input_token,sizeof(followS)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token) {
case t_id:{
cout<< ("predict stmt --> id := R\n");
//std::string id = token_image;
output += ("(:= "+token_image);
match (t_id);
output += (" "+token_image);
//cout << "id here is "<<id<<endl;
match (t_gets);
relation ();
output += ")";
break;
}
case t_read:
cout<< ("predict stmt --> read id\n");
output += ("(read ");
match (t_read);
output += (token_image+")");
match (t_id);
break;
case t_write:
cout<< ("predict stmt --> write R\n");
match (t_write);
output += "(write ";
relation ();
output += ")";
break;
case t_if:
cout << "predict S -> if R SL fi\n";
output+= "(if ";
match(t_if);
relation ();
output+= " ";
stmt_list ();
output+= ")";
match(t_fi);
break;
case t_do:
cout << "predict S -> do SL od\n";
output+= "(do ";
match(t_do);
stmt_list ();
output+= ")";
match(t_od);
break;
case t_check:
cout << "predict S -> check R\n";
output+= "(check ";
match(t_check);
relation ();
output+= ")";
break;
default: error ();
}
}
//R
void relation(){
if(! (contains(firstR,input_token,sizeof(firstR)/4) || contains(followR, input_token,sizeof(followR)/4))){
cout << "Wrong input detected. Trying to resume. Token is "<<input_token<<endl;
while(! (contains(firstR,input_token,sizeof(firstR)/4) || contains(followR, input_token,sizeof(followR)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token){
case t_id:
case t_literal:
case t_lparen:
cout<< ("predict R --> E ET\n");
expr ();
expr_tail ();
break;
default:
cout << "wrong token! " << input_token;
error ();
}
}
//E
void expr () {
if(! (contains(firstE,input_token,sizeof(firstE)/4) || contains(followE, input_token,sizeof(followE)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstE,input_token,sizeof(firstE)/4) || contains(followE, input_token,sizeof(followE)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token) {
case t_id:
case t_literal:
case t_lparen:
cout<< ("predict E --> term term_tail\n");
term ();
term_tail ();
break;
default: error ();
}
}
//ET
void expr_tail () {
if(! (contains(firstET,input_token,sizeof(firstET)/4) || contains(followET, input_token,sizeof(followET)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstET,input_token,sizeof(firstET)/4) || contains(followET, input_token,sizeof(followET)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token){
case t_eqv:
case t_ne:
case t_smaller:
case t_larger:
case t_es:
case t_el:
cout<< ("predict ET --> ro E\n");
rel_op();
expr();
case t_id:
case t_read:
case t_write:
case t_if:
case t_fi:
case t_do:
case t_od:
case t_check:
case t_eof:
case t_rparen:
cout << ("predict ET --> epsilon\n");
break;
default:
cout << "Token type is "<<input_token;
error ();
}
}
//T
void term () {
if(! (contains(firstT,input_token,sizeof(firstT)/4) || contains(followT, input_token,sizeof(followT)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstT,input_token,sizeof(firstT)/4) || contains(followT, input_token,sizeof(followT)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token) {
case t_id:
case t_literal:
case t_lparen:
cout<< ("predict T --> factor factor_tail\n");
factor ();
factor_tail ();
output += idFO;
idFO = "";
break;
default: error ();
}
}
//TT
void term_tail () {
if(! (contains(firstTT,input_token,sizeof(firstTT)/4) || contains(followTT, input_token,sizeof(followTT)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstTT,input_token,sizeof(firstTT)/4) || contains(followTT, input_token,sizeof(followTT)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token) {
case t_add:
case t_sub:
cout<< ("predict term_tail --> add_op term term_tail\n");
add_op ();
term ();
term_tail ();
break;
case t_id:
case t_read:
case t_write:
case t_if:
case t_fi:
case t_do:
case t_od:
case t_check:
case t_eqv:
case t_ne:
case t_smaller:
case t_larger:
case t_es:
case t_el:
case t_eof:
case t_rparen:
cout<< ("predict term_tail --> epsilon\n");
break; /* epsilon production */
default: error ();
}
}
//FT
void factor_tail () {
if(! (contains(firstFT,input_token,sizeof(firstFT)/4) || contains(followFT, input_token,sizeof(followFT)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstFT,input_token,sizeof(firstFT)/4) || contains(followFT, input_token,sizeof(followFT)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token) {
case t_mul:
case t_div:
cout<< ("predict factor_tail --> mul_op factor factor_tail\n");
//idF += "(";
mul_op ();
factor ();
idF += ")";
cout << "at FT, idF is "<<idF << endl;
factor_tail ();
//output += ")";
break;
case t_add:
case t_sub:
case t_rparen:
case t_id:
case t_read:
case t_write:
case t_if:
case t_fi:
case t_do:
case t_od:
case t_check:
case t_eqv:
case t_ne:
case t_smaller:
case t_larger:
case t_es:
case t_el:
case t_eof:
//idF += ")";
idFO = (idFO + idF);
cout << "at the end of FT, idFO is "<<idFO<<" and idF is "<<idF << endl;
idF = "";
cout<< "predict factor_tail --> epsilon, token = "<<input_token<<endl;
break; /* epsilon production */
default:
cout << "Token here is "<<input_token;
error ();
}
}
//F
void factor () {
if(! (contains(firstF,input_token,sizeof(firstF)/4) || contains(followF, input_token,sizeof(followF)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstF,input_token,sizeof(firstF)/4) || contains(followF, input_token,sizeof(followF)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token) {
case t_id :
cout<< ("predict F --> id\n");
idF += token_image;
match (t_id);
break;
case t_literal:
cout<< ("predict F --> literal\n");
idF += token_image;
match (t_literal);
break;
case t_lparen:
cout<< ("predict F --> ( R )\n");
//output += "(";
idFO += idF;
idF = "";
match (t_lparen);
relation ();
//cout << "idFO is "<<idFO<<" and idF is "<<idF<<endl;
//output += ")";
match (t_rparen);
break;
default: error ();
}
}
//ao
void add_op () {
if(! (contains(firstAo,input_token,sizeof(firstAo)/4) || contains(followOp, input_token,sizeof(followOp)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstAo,input_token,sizeof(firstAo)/4) || contains(followOp, input_token,sizeof(followOp)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token) {
case t_add:
cout<< ("predict add_op --> add\n");
//output += ("(add "+idF);
match (t_add);
break;
case t_sub:
cout<< ("predict add_op --> sub\n");
match (t_sub);
break;
default: error ();
}
}
//mo
void mul_op () {
if(! (contains(firstMo,input_token,sizeof(firstMo)/4) || contains(followOp, input_token,sizeof(followOp)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstMo,input_token,sizeof(firstMo)/4) || contains(followOp, input_token,sizeof(followOp)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch (input_token) {
case t_mul:
cout<< ("predict mul_op --> mul\n");
cout << "idF is currently "<<idF<<endl;
idF = ("(* "+idF+" ");
match (t_mul);
break;
case t_div:
cout<< ("predict mul_op --> div\n");
match (t_div);
break;
default: error ();
}
}
//ro
void rel_op () {
if(! (contains(firstRo,input_token,sizeof(firstRo)/4) || contains(followOp, input_token,sizeof(followOp)/4))){
cout << "Wrong input detected. Trying to resume. \n";
while(! (contains(firstRo,input_token,sizeof(firstRo)/4) || contains(followOp, input_token,sizeof(followOp)/4) || input_token == t_eof)){
input_token = scan();
}
}
switch(input_token){
case t_eqv:
cout << ("predict ro -> ==");
match(t_eqv);
break;
case t_ne:
cout << "predict ro -> <>";
match(t_ne);
break;
case t_smaller:
cout << "predict ro -> <";
match(t_smaller);
break;
case t_larger:
cout << "predict ro -> >";
match(t_larger);
break;
case t_es:
cout << "predict ro -> <=";
match(t_es);
break;
case t_el:
cout << "predict ro -> <=";
match(t_el);
break;
default:
error();
}
}
main () {
input_token = scan ();
program ();
}
| [
"vishnusaivarma@gmail.com"
] | vishnusaivarma@gmail.com |
3a580648469e32f049934b0db64b859cf51d4d3f | 711e5c8b643dd2a93fbcbada982d7ad489fb0169 | /XPSP1/NT/admin/wmi/wbem/winmgmt/esscomp/noncom/ncobjapi/connection.cpp | 8196b9070af8c1dc4a2f9ed7e9d9903485bd9d7f | [] | no_license | aurantst/windows-XP-SP1 | 629a7763c082fd04d3b881e0d32a1cfbd523b5ce | d521b6360fcff4294ae6c5651c539f1b9a6cbb49 | refs/heads/master | 2023-03-21T01:08:39.870106 | 2020-09-28T08:10:11 | 2020-09-28T08:10:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 29,289 | cpp | // Connection.cpp
#include "precomp.h"
#include "Connection.h"
#include "Event.h"
#include "Transport.h"
#include "NamedPipe.h"
#include "Inproc.h"
#include "NCDefs.h"
#include "dutils.h"
#define DEF_BATCH_BUFFER_SIZE 131072
#define DEF_SEND_LATENCY 1000
/////////////////////////////////////////////////////////////////////////////
// CSink
#ifdef USE_SD
CSink::CSink() :
m_bufferSD(0)
#else
CSink::CSink()
#endif
{
InitializeCriticalSection(&m_cs);
}
CSink::~CSink()
{
// Make sure none of the still alive events are referencing us.
{
CInCritSec cs(&m_cs);
for (CEventListIterator event = m_listEvents.begin();
event != m_listEvents.end(); event++)
{
CEvent *pEvent = *event;
pEvent->m_pSink = NULL;
}
}
DeleteCriticalSection(&m_cs);
}
BOOL CSink::Init(
CConnection *pConnection,
DWORD dwSinkID,
LPVOID pUserData,
LPEVENT_SOURCE_CALLBACK pCallback)
{
m_pConnection = pConnection;
m_dwSinkID = dwSinkID;
m_pUserData = pUserData;
m_pCallback = pCallback;
return TRUE;
}
void CSink::AddEvent(CEvent *pEvent)
{
CInCritSec cs(&m_cs);
m_listEvents.push_back(pEvent);
}
void CSink::RemoveEvent(CEvent *pEvent)
{
CInCritSec cs(&m_cs);
m_listEvents.remove(pEvent);
}
void CSink::ResetEventBufferLayoutSent()
{
CInCritSec cs(&m_cs);
for (CEventListIterator i = m_listEvents.begin();
i != m_listEvents.end(); i++)
{
CEvent *pEvent = *i;
pEvent->ResetLayoutSent();
#ifdef USE_SD
pEvent->ResetSDSent();
#endif
pEvent->SetEnabled(FALSE);
}
}
void CSink::EnableAndDisableEvents()
{
// For each event, set its enabled value.
for (CEventListIterator i = m_listEvents.begin();
i != m_listEvents.end();
i++)
{
CEvent *pEvent = *i;
EnableEventUsingList(pEvent);
}
}
void CSink::AddToEnabledEventList(CBuffer *pBuffer)
{
DWORD dwLen;
// Add the event names to our enabled map.
for (LPCWSTR szCurrentEvent = pBuffer->ReadAlignedLenString(&dwLen);
*szCurrentEvent != 0;
szCurrentEvent = pBuffer->ReadAlignedLenString(&dwLen))
{
m_mapEnabledEvents[szCurrentEvent] = 1;
TRACE("Enabled: %S", szCurrentEvent);
}
EnableAndDisableEvents();
}
void CSink::RemoveFromEnabledEventList(CBuffer *pBuffer)
{
DWORD dwLen;
for (LPCWSTR szCurrentEvent = pBuffer->ReadAlignedLenString(&dwLen);
*szCurrentEvent != 0;
szCurrentEvent = pBuffer->ReadAlignedLenString(&dwLen))
{
m_mapEnabledEvents.erase(szCurrentEvent);
TRACE("Disabled: %S", szCurrentEvent);
}
EnableAndDisableEvents();
}
BOOL CSink::IsEventClassEnabled(LPCWSTR szEventClass)
{
BOOL bEnable;
WCHAR szTempClassName[1024];
if (szEventClass)
{
wcscpy(szTempClassName, szEventClass);
_wcsupr(szTempClassName);
bEnable =
m_mapEnabledEvents.find(szTempClassName) != m_mapEnabledEvents.end();
}
else
bEnable = FALSE;
return bEnable;
}
void CSink::EnableEventUsingList(CEvent *pEvent)
{
BOOL bEnable;
bEnable = IsEventClassEnabled(pEvent->GetClassName());
pEvent->SetEnabled(bEnable);
}
#ifdef USE_SD
BOOL CSink::SetSD(SECURITY_DESCRIPTOR *pSD)
{
SECURITY_DESCRIPTOR *pSDRelative;
BOOL bRet,
bFree;
if (GetRelativeSD(pSD, &pSDRelative, &bFree))
{
DWORD dwLen = GetSecurityDescriptorLength(pSDRelative);
{
CInCritSec cs(&m_cs);
m_bufferSD.Reset(dwLen + sizeof(DWORD) * 3);
m_bufferSD.Write((DWORD) NC_SRVMSG_SET_SINK_SD);
m_bufferSD.Write(GetSinkID());
m_bufferSD.Write(dwLen);
m_bufferSD.Write(pSDRelative, dwLen);
if (m_pConnection->IsReady())
{
m_pConnection->m_pTransport->SendData(
m_bufferSD.m_pBuffer,
m_bufferSD.GetUsedSize());
}
}
bRet = TRUE;
if (bFree)
delete pSDRelative;
}
else
bRet = FALSE;
return bRet;
}
#endif
BOOL CSink::AddRestrictions(DWORD nQueries, LPCWSTR *pszQueries)
{
DWORD nLenNeeded = sizeof(DWORD) * 2;
for (DWORD i = 0; i < nQueries; i++)
nLenNeeded += (wcslen(pszQueries[i]) + 1) * sizeof(WCHAR);
// Grow the buffer to the right size.
m_bufferRestrictions.Reset(nLenNeeded);
m_bufferRestrictions.Write((DWORD) NC_SRVMSG_RESTRICTED_SINK);
m_bufferRestrictions.Write(GetSinkID());
m_bufferRestrictions.Write(nQueries);
for (i = 0; i < nQueries; i++)
m_bufferRestrictions.Write(pszQueries[i]);
// Send the restrictions if our connection is ready.
if (GetConnection()->IsReady())
{
GetConnection()->m_pTransport->SendData(
m_bufferRestrictions.m_pBuffer,
m_bufferRestrictions.GetUsedSize());
}
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CConnection
CConnection::CConnection(BOOL bBatchSend, DWORD dwBatchBufferSize,
DWORD dwMaxSendLatency) :
m_bDone(FALSE),
m_bUseBatchSend(bBatchSend),
m_dwSendLatency(dwMaxSendLatency ? dwMaxSendLatency : DEF_SEND_LATENCY),
m_heventBufferNotFull(NULL),
m_heventBufferFull(NULL),
m_heventEventsPending(NULL),
m_heventDone(NULL),
m_hthreadSend(NULL),
m_pTransport(NULL),
m_hthreadWMIInit(NULL),
m_heventWMIInit(NULL),
m_bWMIResync(TRUE),
m_dwNextSinkID(1)
{
if (bBatchSend)
{
if (dwBatchBufferSize == 0)
dwBatchBufferSize = DEF_BATCH_BUFFER_SIZE;
m_bufferSend.Reset(dwBatchBufferSize);
}
else
m_bufferSend.Reset(DEF_BATCH_BUFFER_SIZE);
}
CConnection::~CConnection()
{
Deinit();
}
void CConnection::GetBaseName(LPCWSTR szName, LPWSTR szBase)
{
wcscpy(szBase, szName);
_wcsupr(szBase);
// Get rid of the '\' chars since we can't use it in OS object names.
for (WCHAR *szCurrent = szBase; *szCurrent; szCurrent++)
{
if (*szCurrent == '\\')
*szCurrent = '/';
}
}
BOOL CConnection::Init(
LPCWSTR szNamespace,
LPCWSTR szProviderName,
LPVOID pUserData,
LPEVENT_SOURCE_CALLBACK pCallback)
{
if (!m_sinkMain.Init(this, 0, pUserData, pCallback))
return FALSE;
GetBaseName(szNamespace, m_szBaseNamespace);
GetBaseName(szProviderName, m_szBaseProviderName);
try
{
InitializeCriticalSection(&m_cs);
// The rest of these are for batch sending.
InitializeCriticalSection(&m_csBuffer);
}
catch(...)
{
return FALSE;
}
m_heventDone =
CreateEvent(
NULL,
TRUE,
FALSE,
NULL);
if(m_heventDone == NULL)
return FALSE;
m_heventBufferNotFull =
CreateEvent(
NULL,
TRUE,
TRUE,
NULL);
if(m_heventBufferNotFull == NULL)
return FALSE;
m_heventBufferFull =
CreateEvent(
NULL,
TRUE,
FALSE,
NULL);
if(m_heventBufferFull == NULL)
return FALSE;
m_heventEventsPending =
CreateEvent(
NULL,
TRUE,
FALSE,
NULL);
if(m_heventEventsPending == NULL)
return FALSE;
if(!StartWaitWMIInitThread())
return FALSE;
return TRUE;
}
BOOL CConnection::StartWaitWMIInitThread()
{
TRACE("Entered StartWaitWMIInitThread.");
m_heventWMIInit =
OpenEventW(
SYNCHRONIZE,
FALSE,
WMI_INIT_EVENT_NAME);
if (!m_heventWMIInit)
{
PSECURITY_DESCRIPTOR pSD = NULL;
DWORD dwSize;
ConvertStringSecurityDescriptorToSecurityDescriptorW(
ESS_EVENT_SDDL, // security descriptor string
SDDL_REVISION_1, // revision level
&pSD, // SD
&dwSize);
SECURITY_ATTRIBUTES sa = { sizeof(sa), pSD, FALSE };
m_heventWMIInit =
CreateEventW(
&sa,
TRUE,
FALSE,
WMI_INIT_EVENT_NAME);
if (pSD)
LocalFree((HLOCAL) pSD);
if (!m_heventWMIInit)
{
TRACE("Couldn't create ESS ready event: %d", GetLastError());
return FALSE;
}
}
if (WaitForSingleObject(m_heventWMIInit, 0) == 0)
{
TRACE("ESS event was already set, so going to init transport...");
if(!InitTransport())
return FALSE;
}
else
{
DWORD dwID;
TRACE("Creating WaitWMIInitThreadProc thread.");
m_hthreadWMIInit =
CreateThread(
NULL,
0,
(LPTHREAD_START_ROUTINE) WaitWMIInitThreadProc,
this,
0,
&dwID);
if(m_hthreadWMIInit == NULL)
return FALSE;
}
return TRUE;
}
#define COUNTOF(x) (sizeof(x)/sizeof(x[0]))
BOOL CConnection::InitTransport()
{
if ( m_pTransport != NULL )
{
return TRUE;
}
TRACE("Entered InitTransport.");
// Figure out which transport to use.
WCHAR szFullFileName[MAX_PATH * 2] = L"",
*szFileName;
BOOL bRet;
TRACE("Entered InitTransport.");
GetModuleFileNameW(
NULL, szFullFileName, COUNTOF(szFullFileName));
szFileName = wcsrchr(szFullFileName, '\\');
try
{
if (!szFileName || _wcsicmp(szFileName + 1, L"WINMGMT.EXE"))
m_pTransport = new CNamedPipeClient;
else
m_pTransport = new CInprocClient;
}
catch(...)
{
// this page intentionally left blank - m_pTransport will still be NULL.
}
if (m_pTransport)
{
m_pTransport->SetConnection(this);
m_pTransport->Init(m_szBaseNamespace, m_szBaseProviderName);
bRet = TRUE;
}
else
bRet = FALSE;
return bRet;
}
DWORD CConnection::WaitWMIInitThreadProc(CConnection *pThis)
{
TRACE("Entered WaitWMIInitThreadProc");
HANDLE hWait[2] = { pThis->m_heventDone, pThis->m_heventWMIInit };
DWORD dwWait;
dwWait = WaitForMultipleObjects(2, hWait, FALSE, INFINITE);
if (dwWait == 1)
{
TRACE("ESS event fired, going to init transport");
// If WMI is now ready, startup our transport.
pThis->InitTransport();
pThis->m_bWMIResync = FALSE;
}
else
{
TRACE("dwWait in WaitWMIInitThreadProc = %d", dwWait);
}
return 0;
}
BOOL CConnection::ResyncWithWMI()
{
m_bWMIResync = TRUE;
StopThreads();
ResetEvent( m_heventDone) ;
m_hthreadWMIInit = CreateThread(
NULL,
0,
(LPTHREAD_START_ROUTINE)WaitWMIInitThreadProc,
this,
0,
NULL );
return m_hthreadWMIInit != NULL ? TRUE : FALSE;
}
void CConnection::StopThreads()
{
if (m_hthreadSend)
{
BOOL bDoneSending;
do
{
Lock();
bDoneSending = m_bufferSend.GetUsedSize() == 0;
// If there's still stuff left to send, make sure it
// gets sent.
if (bDoneSending)
{
SetEvent(m_heventDone);
Unlock();
WaitForSingleObject(m_hthreadSend, INFINITE);
CloseHandle(m_hthreadSend);
m_hthreadSend = NULL;
}
else
{
SetEvent(m_heventBufferFull);
Unlock();
// Sleep a little to give the send thread a chance to do its
// thing.
Sleep(1);
}
} while (!bDoneSending);
}
if ( m_hthreadWMIInit != NULL )
{
SetEvent(m_heventDone);
WaitForSingleObject(m_hthreadWMIInit, INFINITE);
CloseHandle(m_hthreadWMIInit);
}
m_hthreadWMIInit = NULL;
m_hthreadSend = NULL;
}
void CConnection::Deinit()
{
m_bDone = TRUE;
StopThreads();
if (m_heventWMIInit)
CloseHandle(m_heventWMIInit);
CloseHandle(m_heventDone);
CloseHandle(m_heventBufferNotFull);
CloseHandle(m_heventBufferFull);
CloseHandle(m_heventEventsPending);
// Give the transport a chance to clean up.
if (m_pTransport)
m_pTransport->Deinit();
// Make sure no sinks are referencing us anymore.
for (CSinkMapIterator i = m_mapSink.begin();
i != m_mapSink.end();
i++)
{
CSink *pSink = (*i).second;
pSink->m_pConnection = NULL;
}
DeleteCriticalSection(&m_csBuffer);
DeleteCriticalSection(&m_cs);
}
BOOL CConnection::StartSendThread()
{
DWORD dwID;
m_hthreadSend =
CreateThread(
NULL,
0,
(LPTHREAD_START_ROUTINE) SendThreadProc,
this,
0,
&dwID);
if(m_hthreadSend == NULL)
return FALSE;
return TRUE;
}
DWORD WINAPI CConnection::SendThreadProc(CConnection *pThis)
{
HANDLE hWait[2] = { pThis->m_heventDone, pThis->m_heventEventsPending },
hwaitSendLatency[2] = { pThis->m_heventDone, pThis->m_heventBufferFull },
heventBufferNotFull = pThis->m_heventBufferNotFull;
DWORD dwSendLatency = pThis->m_dwSendLatency;
LPBYTE pData = pThis->m_bufferSend.m_pBuffer;
CBuffer *pBuffer = &pThis->m_bufferSend;
CRITICAL_SECTION *pCS = &pThis->m_csBuffer;
while (WaitForMultipleObjects(2, hWait, FALSE, INFINITE) != 0)
{
// If we have a send latency, wait for that time or until the send
// buffer is full. If the done event fires, get out.
if (dwSendLatency)
{
if (WaitForMultipleObjects(2, hwaitSendLatency, FALSE,
dwSendLatency) == 0)
break;
// Reset m_heventBufferFull.
ResetEvent(hwaitSendLatency[1]);
}
EnterCriticalSection(pCS);
pThis->SendDataOverTransports(
pData,
pBuffer->GetUsedSize());
pBuffer->Reset();
SetEvent(heventBufferNotFull);
// Reset m_heventEventsPending
ResetEvent(hWait[1]);
LeaveCriticalSection(pCS);
}
return 0;
}
//#define NO_SEND
BOOL CConnection::IndicateProvEnabled()
{
// Get out if we're already done.
if (m_bDone)
return TRUE;
CInCritSec cs(&m_cs);
// Tell the callback that the provider is now activated.
if (m_sinkMain.m_pCallback)
m_sinkMain.m_pCallback(
(HANDLE) this, ESM_START_SENDING_EVENTS, m_sinkMain.m_pUserData, NULL);
// Tell the server about us.
if(!SendInitInfo())
return FALSE;
// See if we've buffered any events while we were waiting for WMI to come
// up. If we did, send them on their way.
DWORD dwSize;
EnterCriticalSection(&m_csBuffer);
dwSize = m_bufferSend.GetUsedSize();
if (dwSize)
{
m_pTransport->SendData(m_bufferSend.m_pBuffer, dwSize);
m_bufferSend.Reset();
}
LeaveCriticalSection(&m_csBuffer);
if (m_bUseBatchSend && m_hthreadSend == NULL)
return StartSendThread();
else
return TRUE;
}
void CConnection::IndicateProvDisabled()
{
// Get out if we're already done.
if (m_bDone)
return;
CInCritSec cs(&m_cs);
for (CSinkMapIterator i = m_mapSink.begin();
i != m_mapSink.end();
i++)
{
CSink *pSink = (*i).second;
pSink->ResetEventBufferLayoutSent();
if (pSink->m_pCallback)
{
pSink->m_pCallback(
(HANDLE) pSink,
ESM_STOP_SENDING_EVENTS,
pSink->m_pUserData,
NULL);
}
}
// Tell the callback that the provider is now deactivated.
m_sinkMain.ResetEventBufferLayoutSent();
if (m_sinkMain.m_pCallback)
{
m_sinkMain.m_pCallback(
(HANDLE) &m_sinkMain,
ESM_STOP_SENDING_EVENTS,
m_sinkMain.m_pUserData,
NULL);
}
ResyncWithWMI();
}
BOOL CConnection::SendData(LPBYTE pBuffer, DWORD dwSize)
{
// Make sure this event isn't too big.
if (dwSize > m_bufferSend.m_dwSize)
return FALSE;
if (m_bUseBatchSend || WaitingForWMIInit())
{
BOOL bRet = FALSE;
do
{
BOOL bWasEmpty;
EnterCriticalSection(&m_csBuffer);
// See if we have enough room to add our event.
if (dwSize <= m_bufferSend.GetUnusedSize())
{
bWasEmpty = m_bufferSend.GetUsedSize() == 0;
m_bufferSend.Write(pBuffer, dwSize);
bRet = TRUE;
if (bWasEmpty)
SetEvent(m_heventEventsPending);
LeaveCriticalSection(&m_csBuffer);
}
else
{
// If we're not waiting for WMI to initialize, we just need to
// wait for the send thread to finish sending what's in our
// buffer.
if (!WaitingForWMIInit())
{
// Wake up the send latency thread if necessary.
if (m_dwSendLatency)
SetEvent(m_heventBufferFull);
// So we'll block until the send thread sets the event.
ResetEvent(m_heventBufferNotFull);
LeaveCriticalSection(&m_csBuffer);
WaitForSingleObject(m_heventBufferNotFull, INFINITE);
}
// If we're still waiting for WMI to initialize but our buffer
// is full, we need to remove an event to make some room. Make
// sure we only remove event data and not any buffer layouts.
else
{
LPBYTE pCurrent = m_bufferSend.m_pBuffer;
bRet = FALSE;
do
{
// The message is always the 1st, the size 2nd.
DWORD dwMsg = *(DWORD*) pCurrent,
dwMsgSize = ((DWORD*) pCurrent)[1];
#ifdef USE_SD
if (dwMsg != NC_SRVMSG_EVENT_LAYOUT &&
dwMsg != NC_SRVMSG_SET_EVENT_SD)
#else
if (dwMsg != NC_SRVMSG_EVENT_LAYOUT)
#endif
{
// Move back all the data that comes after this event.
memmove(
pCurrent,
pCurrent + dwMsgSize,
m_bufferSend.m_pCurrent - pCurrent - dwMsgSize);
m_bufferSend.m_pCurrent -= dwMsgSize;
// If we finally made enough room, copy in the data
// and get out.
if (dwSize <= m_bufferSend.GetUnusedSize())
{
m_bufferSend.Write(pBuffer, dwSize);
bRet = TRUE;
}
}
else
pCurrent += dwMsgSize;
} while (pCurrent < m_bufferSend.m_pCurrent && !bRet);
LeaveCriticalSection(&m_csBuffer);
// If after going through the buffer we couldn't make
// enough room for this event, return FALSE and get out.
if (!bRet)
break;
}
} // else from if (dwSize <= m_bufferSend.GetUnusedSize())
} while (!bRet);
return bRet;
}
else
return SendDataOverTransports(pBuffer, dwSize);
}
BOOL CConnection::SendDataOverTransports(LPBYTE pBuffer, DWORD dwSize)
{
if (m_pTransport->IsReady())
m_pTransport->SendData(pBuffer, dwSize);
return TRUE;
}
BOOL CConnection::SendInitInfo()
{
BYTE cBuffer[sizeof(DWORD) * 2];
CBuffer buffer(cBuffer, sizeof(cBuffer), CBuffer::ALIGN_DWORD);
BOOL bRet;
buffer.Write((DWORD) NC_SRVMSG_CLIENT_INFO);
buffer.Write((DWORD) (m_bUseBatchSend ? m_bufferSend.m_dwSize : MAX_EVENT_SIZE));
if(!m_pTransport->InitCallback())
return FALSE;
bRet = m_pTransport->SendData(cBuffer, buffer.GetUsedSize());
#ifdef USE_SD
// Send the main SD, if any.
if (m_sinkMain.m_bufferSD.GetUsedSize())
{
bRet =
m_pTransport->SendData(
m_sinkMain.m_bufferSD.m_pBuffer,
m_sinkMain.m_bufferSD.GetUsedSize());
}
#endif
// Send the restricted sinks restrictions and SDs.
for (CSinkMapIterator i = m_mapSink.begin();
bRet && i != m_mapSink.end();
i++)
{
CSink *pSink = (*i).second;
bRet =
m_pTransport->SendData(
pSink->m_bufferRestrictions.m_pBuffer,
pSink->m_bufferRestrictions.GetUsedSize());
#ifdef USE_SD
if (pSink->m_bufferSD.GetUsedSize())
{
bRet =
m_pTransport->SendData(
pSink->m_bufferSD.m_pBuffer,
pSink->m_bufferSD.GetUsedSize());
}
#endif
}
return bRet;
}
HRESULT CConnection::ProcessMessage(LPBYTE pData, DWORD dwSize)
{
// Get out if we're already done.
if (m_bDone)
return S_OK;
DWORD *pdwMsg = (DWORD*) pData;
DWORD *pdwSinkID = (DWORD*) (pdwMsg + 1);
DWORD_PTR dwMsgCookie;
memcpy( &dwMsgCookie, pdwMsg+2, sizeof(dwMsgCookie) );
LPBYTE pMsgBits = (LPBYTE)(pData+sizeof(DWORD)*2+sizeof(DWORD_PTR));
CBuffer buffer(pMsgBits, dwSize - sizeof(DWORD)*2 - sizeof(DWORD_PTR));
HRESULT hr = S_OK;
DWORD dwLen;
switch(*pdwMsg)
{
case NC_CLIMSG_ACCESS_CHECK_REQ:
{
ES_ACCESS_CHECK check;
check.szQueryLanguage = buffer.ReadAlignedLenString(&dwLen);
check.szQuery = buffer.ReadAlignedLenString(&dwLen);
check.dwSidLen = buffer.ReadDWORD();
if (check.dwSidLen != 0)
check.pSid = buffer.m_pCurrent;
else
check.pSid = NULL;
if (m_sinkMain.m_pCallback)
{
hr =
m_sinkMain.m_pCallback(
(HANDLE) &m_sinkMain,
ESM_ACCESS_CHECK,
m_sinkMain.m_pUserData,
&check);
}
NC_SRVMSG_REPLY reply = { NC_SRVMSG_ACCESS_CHECK_REPLY,
hr, dwMsgCookie };
m_pTransport->SendMsgReply(&reply);
break;
}
case NC_CLIMSG_NEW_QUERY_REQ:
{
ES_NEW_QUERY query;
CSink *pSink = GetSink(*pdwSinkID);
if (pSink)
{
query.dwID = buffer.ReadDWORD();
query.szQueryLanguage = buffer.ReadAlignedLenString(&dwLen);
query.szQuery = buffer.ReadAlignedLenString(&dwLen);
// This is the list of event class names that are now
// enabled thanks to this query.
pSink->AddToEnabledEventList(&buffer);
if (pSink->m_pCallback)
{
hr =
pSink->m_pCallback(
(HANDLE) pSink, ESM_NEW_QUERY, pSink->m_pUserData, &query);
}
}
else
TRACE("Sink %d not found.", *pdwSinkID);
m_pTransport->SendMsgReply(NULL);
break;
}
case NC_CLIMSG_CANCEL_QUERY_REQ:
{
ES_CANCEL_QUERY query;
CSink *pSink = GetSink(*pdwSinkID);
if (pSink)
{
query.dwID = buffer.ReadDWORD();
// This is the list of event class names that are now
// disabled thanks to this query.
pSink->RemoveFromEnabledEventList(&buffer);
if (pSink->m_pCallback)
{
hr =
pSink->m_pCallback(
(HANDLE) pSink, ESM_CANCEL_QUERY, pSink->m_pUserData,
&query);
m_pTransport->SendMsgReply(NULL);
break;
}
else
hr = S_OK;
}
else
TRACE("Sink %d not found.", *pdwSinkID);
break;
}
case NC_CLIMSG_PROVIDER_UNLOADING:
TRACE("Got the NC_CLIMSG_PROVIDER_UNLOADING message.");
// Give our named pipe client a chance to go see if it
// should deactivate itself (if the server doesn't need
// us anymore).
m_pTransport->SignalProviderDisabled();
hr = S_OK;
break;
default:
TRACE("Bad message from server!");
break;
} // switch(*(DWORD*)cBuffer)
return hr;
}
#ifdef USE_SD
// Security helper
BOOL GetRelativeSD(
SECURITY_DESCRIPTOR *pSDIn,
SECURITY_DESCRIPTOR **ppSDOut,
BOOL *pbFree)
{
SECURITY_DESCRIPTOR_CONTROL ctrl;
BOOL bRet;
DWORD dwRev;
bRet =
GetSecurityDescriptorControl(
pSDIn,
&ctrl,
&dwRev);
if (bRet)
{
if (ctrl & SE_SELF_RELATIVE)
{
*ppSDOut = pSDIn;
*pbFree = FALSE;
}
else
{
DWORD dwSizeNeeded = 0;
// Until we prove otherwise...
bRet = FALSE;
MakeSelfRelativeSD(
pSDIn,
pSDIn,
&dwSizeNeeded);
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
*ppSDOut = (SECURITY_DESCRIPTOR*) new BYTE[dwSizeNeeded];
if (*ppSDOut)
{
bRet =
MakeSelfRelativeSD(
pSDIn,
*ppSDOut,
&dwSizeNeeded);
*pbFree = TRUE;
}
}
}
}
return bRet;
}
#endif
CSink *CConnection::CreateSink(
LPVOID pUserData,
LPEVENT_SOURCE_CALLBACK pCallback)
{
CInCritSec cs(&m_cs);
DWORD dwID = m_dwNextSinkID;
CSink *pSink = new CSink;
if (pSink && pSink->Init(this, dwID, pUserData, pCallback))
{
m_mapSink[dwID] = pSink;
m_dwNextSinkID++;
}
return pSink;
}
CSink *CConnection::GetSink(DWORD dwID)
{
if (dwID == 0)
return &m_sinkMain;
else
{
CInCritSec cs(&m_cs);
CSinkMapIterator i = m_mapSink.find(dwID);
CSink *pSink;
if (i != m_mapSink.end())
pSink = (*i).second;
else
pSink = NULL;
return pSink;
}
}
void CConnection::RemoveSink(CSink *pSink)
{
CInCritSec cs(&m_cs);
for (CSinkMapIterator i = m_mapSink.begin(); i != m_mapSink.end(); i++)
{
if ((*i).second == pSink)
{
m_mapSink.erase(i);
pSink->m_pConnection = NULL;
break;
}
}
}
| [
"112426112@qq.com"
] | 112426112@qq.com |
126a3306c22ae510567231daa06c995a0669e4cb | d4523fe1801308befc5fd82db07d96e6cae3da2c | /Martin/main.cpp | f256c5cb05a4d017f40ab881e8d1a62833f48df5 | [] | no_license | jkrautter/tuberculosis | 531acefc51e1ba69dd2c3bd101688bd443a15c3b | 7d629c30258c58f7305ce8d0db37525aadd556ac | refs/heads/master | 2021-01-10T09:51:44.923698 | 2015-12-13T04:37:38 | 2015-12-13T04:37:38 | 47,602,790 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,057 | cpp | #include <iostream>
#include "image_read.h"
#include "opencl_init.h"
#include "features.h"
#include "opencv\cv.h"
#include <list>
using namespace std;
int main(int argc, char* argv[])
{
IMAGE picture;
MATRIX input_mat;
PMATRIX gradient;
char *files[] = { "input0.bmp", "input1.bmp","input2.bmp","input3.bmp" };
list<char *> file_list;
file_list.insert(file_list.end(), files[0]);
file_list.insert(file_list.end(), files[1]);
file_list.insert(file_list.end(), files[2]);
file_list.insert(file_list.end(), files[3]);
read_matrix(file_list, input_mat);
//read_bmp("input.bmp", picture);
read_matrix(files, 4, input_mat);
OCL_DEVICES my_devices;
opencl_init(&my_devices);
long long t1 = cv::getTickCount();
gradient = get_gradient_feature2(input_mat, &my_devices);
long long t2 = cv::getTickCount();
//cout << "freq: " << cvGetTickFrequency() << endl;
cout << "time: " << (t2 - t1) / cv::getTickFrequency() << " s" << endl;
//save_matrix("input.bmp", input_mat, "test");
save_matrix("input.bmp", *gradient, "output");
return 0;
} | [
"fastbullet@web.de"
] | fastbullet@web.de |
5cfbf8ef45ec4f16bbcb27c1cd68ed3875d7c0b4 | d0c44dd3da2ef8c0ff835982a437946cbf4d2940 | /cmake-build-debug/programs_tiling/function14518/function14518_schedule_33/function14518_schedule_33.cpp | 45fcb67601d01f82520bc408811344800aa7b538 | [] | no_license | IsraMekki/tiramisu_code_generator | 8b3f1d63cff62ba9f5242c019058d5a3119184a3 | 5a259d8e244af452e5301126683fa4320c2047a3 | refs/heads/master | 2020-04-29T17:27:57.987172 | 2019-04-23T16:50:32 | 2019-04-23T16:50:32 | 176,297,755 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,017 | cpp | #include <tiramisu/tiramisu.h>
using namespace tiramisu;
int main(int argc, char **argv){
tiramisu::init("function14518_schedule_33");
constant c0("c0", 512), c1("c1", 256), c2("c2", 256);
var i0("i0", 0, c0), i1("i1", 0, c1), i2("i2", 0, c2), i01("i01"), i02("i02"), i03("i03"), i04("i04"), i05("i05"), i06("i06");
input input00("input00", {i0}, p_int32);
input input01("input01", {i1}, p_int32);
computation comp0("comp0", {i0, i1, i2}, input00(i0) + input01(i1));
comp0.tile(i0, i1, i2, 64, 128, 32, i01, i02, i03, i04, i05, i06);
comp0.parallelize(i01);
buffer buf00("buf00", {512}, p_int32, a_input);
buffer buf01("buf01", {256}, p_int32, a_input);
buffer buf0("buf0", {512, 256, 256}, p_int32, a_output);
input00.store_in(&buf00);
input01.store_in(&buf01);
comp0.store_in(&buf0);
tiramisu::codegen({&buf00, &buf01, &buf0}, "../data/programs/function14518/function14518_schedule_33/function14518_schedule_33.o");
return 0;
} | [
"ei_mekki@esi.dz"
] | ei_mekki@esi.dz |
264dd420ee526c64e24c9257a6037146811ce94b | 06cc6e99ee1d0a6ad120763ad004c38d757b77cd | /Codechef/project.cpp | 55790d312975a9dba864fd899defc008886c04e8 | [] | no_license | MaicolGomez/ACM | 0eddec0ba8325c6bdc07721acc57a361c03c4588 | ff23b2c24daa5df1cc864b134886ff81a6d488c7 | refs/heads/master | 2020-03-06T20:57:14.628666 | 2018-03-28T01:46:27 | 2018-03-28T01:51:08 | 127,066,787 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,561 | cpp | #include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
#include<cmath>
#include<algorithm>
#include<climits>
#include<set>
#include<deque>
#include<queue>
#include<map>
#include<climits>
#include<string>
#include<stack>
#include<sstream>
using namespace std;
#define pi (2.0*acos(0.0))
#define eps 1e-6
#define ll long long
#define inf (1<<29)
#define vi vector<int>
#define vll vector<ll>
#define sc(x) scanf("%d",&x)
#define scl(x) scanf("%lld",&x)
#define all(v) v.begin() , v.end()
#define me(a,val) memset( a , val ,sizeof(a) )
#define pb(x) push_back(x)
#define pii pair<int,int>
#define mp(a,b) make_pair(a,b)
#define Q(x) (x) * (x)
#define L(x) ((x<<1) + 1)
#define R(x) ((x<<1) + 2)
#define M(x,y) ((x+y)>>1)
#define fi first
#define se second
#define MOD 1000000007
#define ios ios::sync_with_stdio(0);
#define N 101
ll C[N][N];
ll A[N];
int main(){
C[0][0] = 1;
int r = 0;
for(int i = 1 ; i <= 65 ; i++){
C[i][0] = C[i][i] = 1;
ll x = 1;
bool end = 0;
for(int j = 1 ; j < i ; j++){
C[i][j] = C[i-1][j-1] + C[i-1][j];
x = max( x , C[i][j] );
if( C[i][j] >= (ll)(1e18) ) end = 1;
}
A[i] = x;
if( end ) break;
}
int tc;
sc(tc);
while( tc-- ){
ll n;
scl(n);
if( n == 2 ) printf("2\n");
else{
for(int i = 1 ; i <= 65 ; i++)
if( A[i] >= n ){
printf("%d\n",i);
break;
}
}
}
return 0;
}
| [
"maycolgo@gmail.com"
] | maycolgo@gmail.com |
c97555b452788861234618b605acefbd2ada3de7 | 1e59d40a86cf6d7f6b92f5e002dc21387656aec0 | /JfF/CODE-JfF-B/Devcpp/dev/未命名4.cpp | e77a44c8856fc3f2287a1c34531bbb10b2d0db63 | [] | no_license | Soplia/Codes | 7bb0aecfec57d8bacb33bd1765038d0cffc19e54 | 3704f55b060877f61647b7a0fcf3d2eefe7fa47e | refs/heads/master | 2020-04-20T14:06:36.386774 | 2019-02-02T23:37:21 | 2019-02-02T23:37:21 | 168,888,217 | 0 | 1 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 263 | cpp | #include "stdio.h"
#include "conio.h"
int main()
{
char ch=0;
while(1)
{
ch=getch();
if(ch==75)
printf("¡û\n");
if(ch==77)
printf("¡ú\n");
if(ch==72)
printf("¡ü\n");
if(ch==80)
printf("¡ý\n");
}
return 0;
}
| [
"Soplia@github.com"
] | Soplia@github.com |
2441ca2f00d792af0951976a57d87c85cd7b361d | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/CMake/CMake-gumtree/Kitware_CMake_old_hunk_1672.cpp | 970d438ce1fa275288beedbedad222969a3f2f02 | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 282 | cpp |
/* Construct the executable name from the process id and kwsysProcess
instance. This should be unique. */
sprintf(fwdName, "cmw9xfwd_%u_%p.exe", GetCurrentProcessId(), cp);
/* If we have a temp directory, use it. */
if(length > 0 && length <= _MAX_PATH)
| [
"993273596@qq.com"
] | 993273596@qq.com |
c17724be1752c00e1147d841dde7fd1aa754a5d1 | 0dca3325c194509a48d0c4056909175d6c29f7bc | /ddoscoo/src/model/DescribeWebAreaBlockConfigsResult.cc | c8e5c876d3960cd66637dc24a09e2929854a39c6 | [
"Apache-2.0"
] | permissive | dingshiyu/aliyun-openapi-cpp-sdk | 3eebd9149c2e6a2b835aba9d746ef9e6bef9ad62 | 4edd799a79f9b94330d5705bb0789105b6d0bb44 | refs/heads/master | 2023-07-31T10:11:20.446221 | 2021-09-26T10:08:42 | 2021-09-26T10:08:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,562 | cc | /*
* Copyright 2009-2017 Alibaba Cloud 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 <alibabacloud/ddoscoo/model/DescribeWebAreaBlockConfigsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ddoscoo;
using namespace AlibabaCloud::Ddoscoo::Model;
DescribeWebAreaBlockConfigsResult::DescribeWebAreaBlockConfigsResult() :
ServiceResult()
{}
DescribeWebAreaBlockConfigsResult::DescribeWebAreaBlockConfigsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeWebAreaBlockConfigsResult::~DescribeWebAreaBlockConfigsResult()
{}
void DescribeWebAreaBlockConfigsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allAreaBlockConfigsNode = value["AreaBlockConfigs"]["AreaBlockConfig"];
for (auto valueAreaBlockConfigsAreaBlockConfig : allAreaBlockConfigsNode)
{
AreaBlockConfig areaBlockConfigsObject;
if(!valueAreaBlockConfigsAreaBlockConfig["Domain"].isNull())
areaBlockConfigsObject.domain = valueAreaBlockConfigsAreaBlockConfig["Domain"].asString();
auto allRegionListNode = valueAreaBlockConfigsAreaBlockConfig["RegionList"]["Region"];
for (auto valueAreaBlockConfigsAreaBlockConfigRegionListRegion : allRegionListNode)
{
AreaBlockConfig::Region regionListObject;
if(!valueAreaBlockConfigsAreaBlockConfigRegionListRegion["Block"].isNull())
regionListObject.block = std::stoi(valueAreaBlockConfigsAreaBlockConfigRegionListRegion["Block"].asString());
if(!valueAreaBlockConfigsAreaBlockConfigRegionListRegion["Region"].isNull())
regionListObject.region = valueAreaBlockConfigsAreaBlockConfigRegionListRegion["Region"].asString();
areaBlockConfigsObject.regionList.push_back(regionListObject);
}
areaBlockConfigs_.push_back(areaBlockConfigsObject);
}
}
std::vector<DescribeWebAreaBlockConfigsResult::AreaBlockConfig> DescribeWebAreaBlockConfigsResult::getAreaBlockConfigs()const
{
return areaBlockConfigs_;
}
| [
"sdk-team@alibabacloud.com"
] | sdk-team@alibabacloud.com |
e4b333c4e02eae27d5b9d5685eab7b20843a99f3 | fd35832226f87e0cd5221d96484d82088bf01fd7 | /applicationGUI/mainGUI/windows/wdevicemanager.h | 048401136d32dd4ed36bfe4c8cb54741c0267b8a | [] | no_license | MiniBullLab/ai_system | f694bbf6c23e2599729c75b9b17436748a04c80b | 07ef72454d68099642f71ea6f6374f2a62a8449e | refs/heads/main | 2023-07-13T05:20:24.462401 | 2021-08-21T05:16:14 | 2021-08-21T05:16:14 | 398,184,386 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 516 | h | #ifndef WDEVICEMANAGER_H
#define WDEVICEMANAGER_H
#include <QFrame>
#include <QToolButton>
#include <QStackedWidget>
class WDeviceManager : public QFrame
{
Q_OBJECT
public:
explicit WDeviceManager(QWidget *parent = 0);
signals:
public slots:
private slots:
void on_btnClicked();
private:
void initData();
void initUI();
void initConnect();
private:
QToolButton *tbtnServer;
QStackedWidget *stackedWidget;
QList<QToolButton *> tbtnGroup;
};
#endif // WDEVICEMANAGER_H
| [
"1014153254@qq.com"
] | 1014153254@qq.com |
1cd5fa612d192851cdfc407004c3061d29a18077 | 547014a4981e64f3aa4cbb5e8805a7e34aed39c4 | /31.考新郎 (10分).cpp | 4ef80e0a551e08bbc1894f37b106574243ec3827 | [] | no_license | hushhw/CTGUOJ | 8aa085ac472e06bf4a7beb31dde085ad6664958d | c4b6d1543d9cc3183051557635ddba9b1f727afc | refs/heads/master | 2021-09-07T09:57:00.782286 | 2018-02-20T20:33:18 | 2018-02-20T20:33:18 | 113,444,608 | 2 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,301 | cpp | // 4.考新郎 (10分)
// C时间限制：1 毫秒 | C内存限制：3000 Kb
// 题目内容：
// 国庆期间,省城HZ刚刚举行了一场盛大的集体婚礼,为了使婚礼进行的丰富一些,司仪临时想出了有一个有意思的节目,叫做"考新郎",具体的操作是这样的:首先,给每位新娘打扮得几乎一模一样,并盖上大大的红盖头随机坐成一排;然后,让各位新郎寻找自己的新娘.每人只准找一个,并且不允许多人找一个.最后,揭开盖头,如果找错了对象就要当众跪搓衣板..
// 假设一共有N对新婚夫妇,其中有M个新郎找错了新娘,求发生这种情况一共有多少种可能.
// 输入描述
// N M
//
// 输出描述
// 可能的种数
//
// 输入样例
// 3 2
//
// 输出样例
// 3
#include <cstdio>
#include <iostream>
using namespace std;
long long f[22];
void init()//错排
{
f[1]=0;
f[2]=1;
for(int i=3;i<=20;i++)
{
f[i]=(i-1)*(f[i-1]+f[i-2]);
}
return ;
}
int main()
{
int N,M;
init();
while(scanf("%d%d",&N,&M)!=EOF)
{
int x=N,y=M;
if(M>N/2)
M = N - M;
int sum=0, sum_a=1, sum_b=1;
for(int i=1; i<=M; i++)
sum_b *= i;
while(M)
{
sum_a*=N;
N--;
M--;
}
sum = sum_a/sum_b;
cout<<sum*f[y]<<endl;
}
return 0;
} | [
"hushhw@sina.cn"
] | hushhw@sina.cn |
cc57fd78d55cf461343f4f2054e24e48e6515841 | 72d9009d19e92b721d5cc0e8f8045e1145921130 | /PoissonBinomial/inst/testfiles/dgpb_conv/libFuzzer_dgpb_conv/dgpb_conv_DeepState_TestHarness.cpp | 6a47bca65cf38822e3b8eb5f59b2fa4e4a925c54 | [] | no_license | akhikolla/TestedPackages-NoIssues | be46c49c0836b3f0cf60e247087089868adf7a62 | eb8d498cc132def615c090941bc172e17fdce267 | refs/heads/master | 2023-03-01T09:10:17.227119 | 2021-01-25T19:44:44 | 2021-01-25T19:44:44 | 332,027,727 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,382 | cpp | // AUTOMATICALLY GENERATED BY RCPPDEEPSTATE PLEASE DO NOT EDIT BY HAND, INSTEAD EDIT
// dgpb_conv_DeepState_TestHarness_generation.cpp and dgpb_conv_DeepState_TestHarness_checks.cpp
#include <fstream>
#include <RInside.h>
#include <iostream>
#include <RcppDeepState.h>
#include <qs.h>
#include <DeepState.hpp>
NumericVector dgpb_conv(const IntegerVector obs, const NumericVector probs, const IntegerVector val_p, const IntegerVector val_q);
TEST(PoissonBinomial_deepstate_test,dgpb_conv_test){
static int rinside_flag = 0;
if(rinside_flag == 0)
{
rinside_flag = 1;
RInside R;
} std::time_t current_timestamp = std::time(0);
std::cout << "input starts" << std::endl;
IntegerVector obs = RcppDeepState_IntegerVector();
std::string obs_t = "/home/akhila/fuzzer_packages/fuzzedpackages/PoissonBinomial/inst/testfiles/dgpb_conv/libFuzzer_dgpb_conv/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_obs.qs";
qs::c_qsave(obs,obs_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "obs values: "<< obs << std::endl;
NumericVector probs = RcppDeepState_NumericVector();
std::string probs_t = "/home/akhila/fuzzer_packages/fuzzedpackages/PoissonBinomial/inst/testfiles/dgpb_conv/libFuzzer_dgpb_conv/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_probs.qs";
qs::c_qsave(probs,probs_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "probs values: "<< probs << std::endl;
IntegerVector val_p = RcppDeepState_IntegerVector();
std::string val_p_t = "/home/akhila/fuzzer_packages/fuzzedpackages/PoissonBinomial/inst/testfiles/dgpb_conv/libFuzzer_dgpb_conv/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_val_p.qs";
qs::c_qsave(val_p,val_p_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "val_p values: "<< val_p << std::endl;
IntegerVector val_q = RcppDeepState_IntegerVector();
std::string val_q_t = "/home/akhila/fuzzer_packages/fuzzedpackages/PoissonBinomial/inst/testfiles/dgpb_conv/libFuzzer_dgpb_conv/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_val_q.qs";
qs::c_qsave(val_q,val_q_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "val_q values: "<< val_q << std::endl;
std::cout << "input ends" << std::endl;
try{
dgpb_conv(obs,probs,val_p,val_q);
}
catch(Rcpp::exception& e){
std::cout<<"Exception Handled"<<std::endl;
}
}
| [
"akhilakollasrinu424jf@gmail.com"
] | akhilakollasrinu424jf@gmail.com |
959a5d8432a4d3d51d72a5ac98319b0b856a3736 | 5d83739af703fb400857cecc69aadaf02e07f8d1 | /Archive2/0f/74a4661c06cd68/main.cpp | 74ec04892645b40fd4adc80bfb0d6b1fa42800ae | [] | no_license | WhiZTiM/coliru | 3a6c4c0bdac566d1aa1c21818118ba70479b0f40 | 2c72c048846c082f943e6c7f9fa8d94aee76979f | refs/heads/master | 2021-01-01T05:10:33.812560 | 2015-08-24T19:09:22 | 2015-08-24T19:09:22 | 56,789,706 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,457 | cpp | #include <iostream>
#include <string>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>
#include <sstream>
#include <assert.h>
using namespace std;
template<class Container, class Iterator>
size_t position(Container&& c, Iterator pos){
return size_t(distance(begin(c), pos));
}
template<class Container, class Iterator, class Iterator2>
string sposition(Container&& c, const pair<Iterator, Iterator2>& pos){
ostringstream r;
r << "(" << position(c, pos.first) << ", " << position(c, pos.second) << ")";
return r.str();
}
template<class Container, class Value>
pair<typename remove_reference<Container>::type::iterator, typename remove_reference<Container>::type::iterator>
binary_search(Container&& source, const Value& item){
assert(is_sorted(begin(source), end(source)));
const auto empty = make_pair(source.end(), source.end());
auto l = begin(source), r=end(source), m=l;
while(true){
if(l==r)
return empty;
const auto lr = distance(l,r);
m = next(l, lr/2);
if(*m<item)
l = m;
if(*m>item)
r = m;
if(*m==item)
break;
if(l!=r && next(l)==r)
return empty;
}
cout<<"part1"<<endl;
auto l1=l, r1=m, l2=m, r2=r;
while(true){
const auto lr1 = distance(l1, r1);
m = next(l1, lr1/2);
if(*m<item)
l1 = m;
if(*m>=item)
r1 = m;
if(l1==r1 || (*l1<item && *r1>=item))
break;
}
cout<<"part2"<<endl;
while(true){
const auto lr2 = distance(l2, r2);
m = next(l2, lr2/2);
if(*m<=item)
l2 = m;
if(*m>item)
r2 = m;
if(l2==r2 || (*l2>=item && (r==r2 || *r2>item)))
break;
}
cout<<"part3"<<endl;
return {r1, next(l2)};
}
int main(){
vector<int> s{5,7,7,7,9,19,23};
list<int> s2(s.begin()+1, s.end());
cout<<sposition(s, binary_search(s, 7))<<endl;
cout<<sposition(s2, binary_search(s2, 7))<<endl;
cout<<sposition(s, binary_search(s, 9))<<endl;
cout<<sposition(s, binary_search(s, 5))<<endl;
cout<<sposition(s, binary_search(s, 23))<<endl;
cout<<sposition(s, binary_search(s, 0))<<endl;
vector<int> e;
cout<<sposition(e, binary_search(e, 0))<<endl;
cout<<sposition(s, binary_search(s, 25))<<endl;
cout<<sposition(s, binary_search(s, 10))<<endl;
return 0;
}
| [
"francis.rammeloo@36614edc-3e3a-acb8-9062-c8ae0e4185df"
] | francis.rammeloo@36614edc-3e3a-acb8-9062-c8ae0e4185df |
73aa6d635161c23d7cf9148814ef45d73f867a2f | 64178ab5958c36c4582e69b6689359f169dc6f0d | /vscode/wg/sdk/FMarkerSyncData.hpp | 776b910af66b8cd0981e5845b0c71ea4c6f731e4 | [] | no_license | c-ber/cber | 47bc1362f180c9e8f0638e40bf716d8ec582e074 | 3cb5c85abd8a6be09e0283d136c87761925072de | refs/heads/master | 2023-06-07T20:07:44.813723 | 2023-02-28T07:43:29 | 2023-02-28T07:43:29 | 40,457,301 | 5 | 5 | null | 2023-05-30T19:14:51 | 2015-08-10T01:37:22 | C++ | UTF-8 | C++ | false | false | 842 | hpp | #pragma once
#ifdef _MSC_VER
#pragma pack(push, 1)
#endif
namespace PUBGSDK {
struct alignas(1) FMarkerSyncData // Size: 0x20
{
public:
TArray<struct FAnimSyncMarker> AuthoredSyncMarkers; /* Ofs: 0x0 Size: 0x10 ArrayProperty Engine.MarkerSyncData.AuthoredSyncMarkers */
uint8_t UnknownData10[0x10];
};
#ifdef VALIDATE_SDK
namespace Validation{
auto constexpr sizeofFMarkerSyncData = sizeof(FMarkerSyncData); // 32
static_assert(sizeof(FMarkerSyncData) == 0x20, "Size of FMarkerSyncData is not correct.");
auto constexpr FMarkerSyncData_AuthoredSyncMarkers_Offset = offsetof(FMarkerSyncData, AuthoredSyncMarkers);
static_assert(FMarkerSyncData_AuthoredSyncMarkers_Offset == 0x0, "FMarkerSyncData::AuthoredSyncMarkers offset is not 0");
}
#endif
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"1395329153@qq.com"
] | 1395329153@qq.com |
7a1b14063591733bcd1ec7394551074359e81b48 | 7dcc021a54186053194fa12fb10f7266dcc6d511 | /src/bin/make-pdf-to-tid-transducer.cc | eef853f53780f04863ac9976c2eac722a68e99da | [
"Apache-2.0",
"LicenseRef-scancode-public-domain"
] | permissive | troylee/kaldi | fcdb3cda8a95f0aae71b05242f5a777a02131351 | 33b9f3bcebca5f2e280c6416f95962d664a1d26d | refs/heads/master | 2020-05-25T10:07:08.210149 | 2014-07-18T08:32:35 | 2014-07-18T08:32:35 | 21,224,820 | 2 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 2,028 | cc | // bin/make-pdf-to-tid-transducer.cc
// Copyright 2009-2011 Microsoft Corporation
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.
#include "hmm/transition-model.h"
#include "hmm/hmm-utils.h"
#include "util/common-utils.h"
#include "fst/fstlib.h"
int main(int argc, char *argv[]) {
#ifdef _MSC_VER
if (0) {
fst::VectorFst<fst::StdArc> *fst = NULL;
fst->Write("");
}
#endif
try {
using namespace kaldi;
typedef kaldi::int32 int32;
using fst::SymbolTable;
using fst::VectorFst;
using fst::StdArc;
const char *usage =
"Make transducer from pdfs to transition-ids\n"
"Usage: make-pdf-to-tid-transducer model-filename [fst-out]\n"
"e.g.: \n"
" make-pdf-to-tid-transducer 1.mdl > pdf2tid.fst\n";
ParseOptions po(usage);
po.Read(argc, argv);
if (po.NumArgs() <1 || po.NumArgs() > 2) {
po.PrintUsage();
exit(1);
}
std::string trans_model_filename = po.GetArg(1);
std::string fst_out_filename = po.GetOptArg(2);
TransitionModel trans_model;
ReadKaldiObject(trans_model_filename, &trans_model);
fst::VectorFst<fst::StdArc> *fst = GetPdfToTransitionIdTransducer(trans_model);
if (!fst->Write(fst_out_filename))
KALDI_ERR << "Error writing fst to "
<< (fst_out_filename == "" ? "standard output" : fst_out_filename);
delete fst;
} catch(const std::exception &e) {
std::cerr << e.what();
return -1;
}
}
| [
"troy.lee2008@gmail.com"
] | troy.lee2008@gmail.com |
c6c1016dbe63d7911cf9f384aae7b6af520f895e | 44aa76e2dbf8c8dbe83b8c54ea8cdcee7031f5ac | /Algorithms/Sort-Insert.cpp | 357d549455fe7946c71fc88f228123628d7e46ff | [
"MIT"
] | permissive | Avelyev/Cplusplus | b66ab98b7e35e0e47ad827645878db2a60e5606f | 3e9f99e8421ea6f747a6b00302deafffe1f930b6 | refs/heads/master | 2021-01-21T21:57:32.165827 | 2017-06-22T19:09:42 | 2017-06-22T19:09:42 | 95,136,290 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,755 | cpp | /*****************************************************************************
* This example demonstrates the development of algorithm sorting inserts
*
* Этот пример демонстрирует разработку алгоритма сортировки вставками
*
* Code&Robots site: http://codrob.ru/
* YouTube Channel: https://www.youtube.com/c/code_robots
* Social networks: https://vk.com/codrob
* https://www.facebook.com/groups/295824740787675/
*
* This example code is in public domain and licensed under MIT license
*****************************************************************************/
#include <iostream>
#include <functional>
enum type {less, greater};
template <typename T, type e>
void insertSort(T arr[], int n)
{
int passages = 0;
std::function<bool(T,T)> predicate;
switch (e)
{
case greater:
predicate = [] (T x, T y) { return x>y?true:false; };
break;
case less:
predicate = [] (T x, T y) { return x<y?true:false; };
break;
}
//Algorithm
for (int j = 1; j < n; j++)
{
T key = arr[j];
int i = j - 1;
while (i >= 0 && predicate(arr[i], key))
{
passages++;
arr[i+1] = arr[i];
i--;
}
arr[++i] = key;
passages++;
}
//Output
for (int i = 0; i < n; i++)
{
std::cout << arr[i] << ", ";
}
std::cout << "(" << passages << ")" << std::endl;
}
int main()
{
{
int arr[] = {41, 58, 32, 64, 85, 73, 20};
insertSort<int, greater> (arr, 7);
}
{
int arr[] = {35, 58, 32, 45, 85, 73, 827};
insertSort<int, greater> (arr, 7);
}
{
int arr[] = {41, 58, 32, 64, 85, 73, 20};
insertSort<int, less> (arr, 7);
}
{
int arr[] = {35, 58, 32, 45, 85, 73, 827};
insertSort<int, less> (arr, 7);
}
}
| [
"eugene@codrob.ru"
] | eugene@codrob.ru |
a8c6787f49af6acac6ac585331093bbed8cf1c71 | 108c8fa38da3371571068f353888f20d8fd729c0 | /voxel-cutting/Transformer_postProcess/NodeGenerate/Graphics/Surfaceobj.h | 2e4e1885ec6f007d4d3fdf40404d18b4aec28633 | [] | no_license | pigoblock/TFYP | 2dd0acf1bb5591fb31b2d78a1bed764cd4a7d166 | 11ba29fd0d75a6b92080fd80b24064898b8f980f | refs/heads/master | 2021-01-17T10:07:10.149542 | 2016-04-19T07:41:53 | 2016-04-19T07:41:53 | 41,845,421 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,017 | h | #ifndef SURFACE_OBJ
#define SURFACE_OBJ
#include "DataTypes/Define.h"
#include "DataTypes/Vec.h"
#include "DataTypes/Mat.h"
#include "DataTypes/Quat.h"
#include "TopologyContainer.h"
#include "TopologyModifier.h"
#include "Modules/TimeTick.h"
#include "Modules/AABB.h"
#include "Modules/AABBTri.h"
#include <afxwin.h>
#include <GL/glu.h>
#include <GL/gl.h>
#include <vector>
#include <memory>
class SurfaceObj
{
public:
SurfaceObj(void);
~SurfaceObj(void);
//functions
public:
void readObjData(const char* filename);
void readObjDataSTL(const char * filePath);
void init(std::vector<Vec3f> _point, std::vector<Vec3i> _face);
void writeObjData(char* filename);
void writeSTLData(char * filePath);
bool isIntersectWithBox(Box box, bool isInside);
//Drawings
void drawObject();
void drawObject0();
void drawWireFrame0();
void drawWireFrame();
void drawPointsAroundPoint(int idx);
void drawEdgesAroundPoint(int idx);
void drawFacesAroundPoint(int idx);
void drawFacesAroundEdge(int idx);
void drawEdgesInFace(int idx);
void drawPoints();
void drawPointIdx();
void drawFace(int idx);
void drawFaceIdx();
void drawBVH(int depth);
void drawBVH();
void updatePoint();
void updateNormal();
void updateBVH();
void displacePoint( arrayVec3f &pointDisplace, arrayInt &ptIdx );
//Increase the resolution
void increaseResolution();
//Bounding volume hierarchy
void constructAABBTree();
//get values
std::vector<Vec3f>* point0();
std::vector<Vec3f>* point();
std::vector<Vec3f>* dis();
std::vector<Vec3i>* face();
std::vector<Vec2i>* edge();
std::vector<Vec3f>* faceNormal();
std::vector<Vec3f>* pointNormal();
Vec3f midPoint();
AABBTree* getBVH();
int nbPoint();
int nbFace();
TopologyContainer* container();
TopologyModifier* modifier();
void computeCenterPoint();
void computeRotationMatrix(Vec3f axis, float angle, Mat3x3f& rot);
void moveToCenter();
void translateI(float x, float y, float z);
void translateI(Vec3f trans);
void translate(float x, float y, float z);
void translateC(Vec3f trans);
void translate(Vec3f trans);
void scaleI(float scale);
void scaleI(float x, float y, float z);
void scaleC(float x, float y, float z);
void scaleC(float scale);
void scale(float scale);
void scale(float x, float y, float z);
void rotate(Mat3x3f& rot);
void rotateC(Mat3x3f rot);
void rotateC(Quat q);
void rotate(Quat q);
void rotate(float* rot);
void rotateC(Vec3f axis, float angle);
void rotate(Vec3f axis, float angle);
private:
void computeFaceNormal();
Vec3f computeFaceNormal(Vec3f p1, Vec3f p2, Vec3f p3);
void computePointNormal();
//variables
public:
FILE* FTime;
std::vector<Vec3f> Point0;
std::vector<Vec3f> Point;
std::vector<Vec3f> Dis;
std::vector<Vec3i> Face;
std::vector<Vec2i> Edge;
std::vector<Vec3f> FaceNormal;
std::vector<Vec3f> PointNormal;
Vec3f MidPoint;
TopologyContainer* Container;
TopologyModifier* Modifier;
AABBTreeTri* BVHAABB;
};
typedef std::shared_ptr<SurfaceObj> SurfaceObjPtr;
#endif | [
"kowanling@hotmail.com"
] | kowanling@hotmail.com |
7f882ed3c8bcc9b9f38ba14dbd058d7e3854eb21 | 6abaf62b3597610ed8b35f637552ea2a829dbd7e | /src/Plugins/BitmapFontPlugin/BitmapFontPlugin.cpp | 058163eb3bccc47a7d4e01a297afbf75f69e62f1 | [] | no_license | codacy-badger/Mengine | baac6696d51c6eae1201f345698e76755d30dd29 | 36f98378eec5e6351eacc7d9b463c472b9888fd0 | refs/heads/master | 2020-06-24T17:38:21.976520 | 2019-07-26T14:37:15 | 2019-07-26T14:37:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,764 | cpp | #include "BitmapFontPlugin.h"
#include "Interface/StringizeServiceInterface.h"
#include "Interface/PrototypeServiceInterface.h"
#include "Kernel/Logger.h"
#include "BitmapGlyphService.h"
#include "BitmapFontPrototypeGenerator.h"
//////////////////////////////////////////////////////////////////////////
SERVICE_EXTERN( BitmapGlyphService );
//////////////////////////////////////////////////////////////////////////
PLUGIN_FACTORY( BitmapFont, Mengine::BitmapFontPlugin );
//////////////////////////////////////////////////////////////////////////
namespace Mengine
{
//////////////////////////////////////////////////////////////////////////
BitmapFontPlugin::BitmapFontPlugin()
{
}
//////////////////////////////////////////////////////////////////////////
BitmapFontPlugin::~BitmapFontPlugin()
{
}
//////////////////////////////////////////////////////////////////////////
bool BitmapFontPlugin::_initializePlugin()
{
SERVICE_CREATE( BitmapGlyphService );
PROTOTYPE_SERVICE()
->addPrototype( STRINGIZE_STRING_LOCAL( "Font" ), STRINGIZE_STRING_LOCAL( "Bitmap" )
, Helper::makeFactorableUnique<BitmapFontPrototypeGenerator>()
);
return true;
}
//////////////////////////////////////////////////////////////////////////
void BitmapFontPlugin::_finalizePlugin()
{
PROTOTYPE_SERVICE()
->removePrototype( STRINGIZE_STRING_LOCAL( "Font" ), STRINGIZE_STRING_LOCAL( "Bitmap" ) );
SERVICE_FINALIZE( BitmapGlyphService );
}
//////////////////////////////////////////////////////////////////////////
void BitmapFontPlugin::_destroyPlugin()
{
SERVICE_DESTROY( BitmapGlyphService );
}
}
| [
"irov13@mail.ru"
] | irov13@mail.ru |
85ececf8bc371af253f55b733a946d4fa29f20cd | 36579e820f5c07cd1fe796abc777f23f32efeb10 | /src/chrome/browser/chromeos/login/kiosk_browsertest.cc | 26bafcdafb857bf88f3502b0fe2c1730c78649d7 | [
"BSD-3-Clause"
] | permissive | sokolovp/BraveMining | 089ea9940ee6e6cb8108b106198e66c62049d27b | 7040cdee80f6f7176bea0e92f8f3435abce3e0ae | refs/heads/master | 2020-03-20T00:52:22.001918 | 2018-06-12T11:33:31 | 2018-06-12T11:33:31 | 137,058,944 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 93,693 | cc | // Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <memory>
#include <vector>
#include "apps/test/app_window_waiter.h"
#include "ash/shell.h"
#include "ash/wallpaper/wallpaper_controller.h"
#include "ash/wallpaper/wallpaper_controller_observer.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/location.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/path_service.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/sys_info.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/chromeos/app_mode/fake_cws.h"
#include "chrome/browser/chromeos/app_mode/kiosk_app_launch_error.h"
#include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
#include "chrome/browser/chromeos/file_manager/fake_disk_mount_manager.h"
#include "chrome/browser/chromeos/login/app_launch_controller.h"
#include "chrome/browser/chromeos/login/startup_utils.h"
#include "chrome/browser/chromeos/login/test/oobe_base_test.h"
#include "chrome/browser/chromeos/login/test/oobe_screen_waiter.h"
#include "chrome/browser/chromeos/login/ui/login_display_host.h"
#include "chrome/browser/chromeos/login/ui/login_display_host_webui.h"
#include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
#include "chrome/browser/chromeos/login/users/mock_user_manager.h"
#include "chrome/browser/chromeos/login/wizard_controller.h"
#include "chrome/browser/chromeos/ownership/fake_owner_settings_service.h"
#include "chrome/browser/chromeos/policy/device_local_account.h"
#include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
#include "chrome/browser/chromeos/profiles/profile_helper.h"
#include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
#include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
#include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
#include "chrome/browser/extensions/browsertest_util.h"
#include "chrome/browser/extensions/extension_service.h"
#include "chrome/browser/profiles/profile_impl.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "chrome/browser/profiles/profiles_state.h"
#include "chrome/browser/signin/signin_manager_factory.h"
#include "chrome/browser/ui/webui/chromeos/login/kiosk_app_menu_handler.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/pref_names.h"
#include "chromeos/chromeos_switches.h"
#include "chromeos/dbus/cryptohome_client.h"
#include "chromeos/disks/disk_mount_manager.h"
#include "chromeos/settings/cros_settings_provider.h"
#include "components/prefs/pref_service.h"
#include "components/signin/core/browser/signin_manager.h"
#include "components/signin/core/browser/signin_pref_names.h"
#include "components/user_manager/scoped_user_manager.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/web_ui.h"
#include "content/public/test/browser_test_utils.h"
#include "extensions/browser/app_window/app_window.h"
#include "extensions/browser/app_window/app_window_registry.h"
#include "extensions/browser/app_window/native_app_window.h"
#include "extensions/browser/extension_system.h"
#include "extensions/common/manifest.h"
#include "extensions/common/switches.h"
#include "extensions/components/native_app_window/native_app_window_views.h"
#include "extensions/test/extension_test_message_listener.h"
#include "extensions/test/result_catcher.h"
#include "google_apis/gaia/gaia_constants.h"
#include "google_apis/gaia/gaia_switches.h"
#include "google_apis/gaia/gaia_urls.h"
#include "media/audio/mock_audio_manager.h"
#include "media/audio/sounds/audio_stream_handler.h"
#include "media/audio/sounds/sounds_manager.h"
#include "media/audio/test_audio_thread.h"
#include "net/test/embedded_test_server/embedded_test_server.h"
#include "services/audio/public/cpp/fake_system_info.h"
#include "ui/aura/window.h"
#include "ui/base/accelerators/accelerator.h"
#include "ui/keyboard/keyboard_switches.h"
namespace em = enterprise_management;
namespace chromeos {
namespace {
// This is a simple test app that creates an app window and immediately closes
// it again. Webstore data json is in
// chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
// detail/ggbflgnkafappblpkiflbgpmkfdpnhhe
const char kTestKioskApp[] = "ggbflgnkafappblpkiflbgpmkfdpnhhe";
// This app creates a window and declares usage of the identity API in its
// manifest, so we can test device robot token minting via the identity API.
// Webstore data json is in
// chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
// detail/ibjkkfdnfcaoapcpheeijckmpcfkifob
const char kTestEnterpriseKioskApp[] = "ibjkkfdnfcaoapcpheeijckmpcfkifob";
// An offline enable test app. Webstore data json is in
// chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
// detail/ajoggoflpgplnnjkjamcmbepjdjdnpdp
// An app profile with version 1.0.0 installed is in
// chrome/test/data/chromeos/app_mode/offline_enabled_app_profile
// The version 2.0.0 crx is in
// chrome/test/data/chromeos/app_mode/webstore/downloads/
const char kTestOfflineEnabledKioskApp[] = "ajoggoflpgplnnjkjamcmbepjdjdnpdp";
// An app to test local fs data persistence across app update. V1 app writes
// data into local fs. V2 app reads and verifies the data.
// Webstore data json is in
// chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
// detail/bmbpicmpniaclbbpdkfglgipkkebnbjf
const char kTestLocalFsKioskApp[] = "bmbpicmpniaclbbpdkfglgipkkebnbjf";
// An app to test local access to file systems via the
// chrome.fileSystem.requestFileSystem API.
// Webstore data json is in
// chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
// detail/aaedpojejpghjkedenggihopfhfijcko
const char kTestGetVolumeListKioskApp[] = "aaedpojejpghjkedenggihopfhfijcko";
// An app to test Kiosk virtual keyboard API chrome.virtualKeyboard.* .
// Source files are in
// chrome/test/data/chromeos/app_mode/virtual_keyboard/src/
const char kTestVirtualKeyboardKioskApp[] = "fmmbbdiapbcicajbpkpkdbcgidgppada";
// Testing apps for testing kiosk multi-app feature. All the crx files are in
// chrome/test/data/chromeos/app_mode/webstore/downloads.
// Source files are in
// chrome/test/data/chromeos/app_mode/multi_app_kiosk/src/primary_app
const char kTestPrimaryKioskApp[] = "dpejijbnadgcgmabkmcoajkgongfgnii";
// Source files are in
// chrome/test/data/chromeos/app_mode/multi_app_kiosk/src/secondary_app_1
const char kTestSecondaryApp1[] = "emnbflhfbllbehnpjmjddklbkeeoaaeg";
// Source files are in
// chrome/test/data/chromeos/app_mode/multi_app_kiosk/src/secondary_app_2
const char kTestSecondaryApp2[] = "blmjgfbajihimkjmepbhgmjbopjchlda";
// Source files are in
// chrome/test/data/chromeos/app_mode/multi_app_kiosk/src/secondary_app_3
const char kTestSecondaryApp3[] = "jkofhenkpndpdflehcjpcekgecjkpggg";
// Source files are in
// chrome/test/data/chromeos/app_mode/multi_app_kiosk/src/
// secondary_extensions_1
const char kTestSecondaryExtension[] = "gdmgkkoghcihimdfoabkefdkccllcfea";
// Source files are in
// chrome/test/data/chromeos/app_mode/multi_app_kiosk/src/
// shared_module_primary_app
const char kTestSharedModulePrimaryApp[] = "ofmeihgcmabfalhhgooajcijiaoekhkg";
// Source files are in
// chrome/test/data/chromeos/app_mode/multi_app_kiosk/src/secondary_app
const char kTestSecondaryApp[] = "bbmaiojbgkkmfaglfhaplfomobgojhke";
// Source files are in
// chrome/test/data/chromeos/app_mode/multi_app_kiosk/src/shared_module
const char kTestSharedModuleId[] = "biebhpdepndljbnkadldcbjkiedldnmn";
// Source files are in
// chrome/test/data/chromeos/app_mode/multi_app_kiosk/src/
// secondary_extension
const char kTestSecondaryExt[] = "kcoobopfcjmbfeppibolpaolbgbmkcjd";
// Fake usb stick mount path.
const char kFakeUsbMountPathUpdatePass[] =
"chromeos/app_mode/external_update/update_pass";
const char kFakeUsbMountPathNoManifest[] =
"chromeos/app_mode/external_update/no_manifest";
const char kFakeUsbMountPathBadManifest[] =
"chromeos/app_mode/external_update/bad_manifest";
const char kFakeUsbMountPathLowerAppVersion[] =
"chromeos/app_mode/external_update/lower_app_version";
const char kFakeUsbMountPathLowerCrxVersion[] =
"chromeos/app_mode/external_update/lower_crx_version";
const char kFakeUsbMountPathBadCrx[] =
"chromeos/app_mode/external_update/bad_crx";
// Timeout while waiting for network connectivity during tests.
const int kTestNetworkTimeoutSeconds = 1;
// Email of owner account for test.
const char kTestOwnerEmail[] = "owner@example.com";
const char kTestEnterpriseAccountId[] = "enterprise-kiosk-app@localhost";
const char kTestEnterpriseServiceAccountId[] = "service_account@example.com";
const char kTestRefreshToken[] = "fake-refresh-token";
const char kTestUserinfoToken[] = "fake-userinfo-token";
const char kTestLoginToken[] = "fake-login-token";
const char kTestAccessToken[] = "fake-access-token";
const char kTestClientId[] = "fake-client-id";
const char kTestAppScope[] = "https://www.googleapis.com/auth/userinfo.profile";
// Test JS API.
const char kLaunchAppForTestNewAPI[] =
"login.AccountPickerScreen.runAppForTesting";
const char kLaunchAppForTestOldAPI[] = "login.AppsMenuButton.runAppForTesting";
const char kCheckDiagnosticModeNewAPI[] = "$('oobe').confirmDiagnosticMode_";
const char kCheckDiagnosticModeOldAPI[] =
"$('show-apps-button').confirmDiagnosticMode_";
// Helper function for GetConsumerKioskAutoLaunchStatusCallback.
void ConsumerKioskAutoLaunchStatusCheck(
KioskAppManager::ConsumerKioskAutoLaunchStatus* out_status,
const base::Closure& runner_quit_task,
KioskAppManager::ConsumerKioskAutoLaunchStatus in_status) {
LOG(INFO) << "KioskAppManager::ConsumerKioskModeStatus = " << in_status;
*out_status = in_status;
runner_quit_task.Run();
}
// Helper KioskAppManager::EnableKioskModeCallback implementation.
void ConsumerKioskModeAutoStartLockCheck(bool* out_locked,
const base::Closure& runner_quit_task,
bool in_locked) {
LOG(INFO) << "kiosk locked = " << in_locked;
*out_locked = in_locked;
runner_quit_task.Run();
}
// Helper function for WaitForNetworkTimeOut.
void OnNetworkWaitTimedOut(const base::Closure& runner_quit_task) {
runner_quit_task.Run();
}
bool IsAppInstalled(const std::string& app_id, const std::string& version) {
Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
DCHECK(app_profile);
const extensions::Extension* app =
extensions::ExtensionSystem::Get(app_profile)
->extension_service()
->GetInstalledExtension(app_id);
return app != nullptr && version == app->version().GetString();
}
extensions::Manifest::Type GetAppType(const std::string& app_id) {
Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
DCHECK(app_profile);
const extensions::Extension* app =
extensions::ExtensionSystem::Get(app_profile)
->extension_service()
->GetInstalledExtension(app_id);
DCHECK(app);
return app->GetType();
}
void SetPlatformVersion(const std::string& platform_version) {
const std::string lsb_release = base::StringPrintf(
"CHROMEOS_RELEASE_VERSION=%s", platform_version.c_str());
base::SysInfo::SetChromeOSVersionInfoForTest(lsb_release, base::Time::Now());
}
class KioskSessionInitializedWaiter : public KioskAppManagerObserver {
public:
KioskSessionInitializedWaiter() : scoped_observer_(this) {
scoped_observer_.Add(KioskAppManager::Get());
}
~KioskSessionInitializedWaiter() override = default;
void Wait() { run_loop_.Run(); }
// KioskAppManagerObserver:
void OnKioskSessionInitialized() override { run_loop_.Quit(); }
private:
ScopedObserver<KioskAppManager, KioskAppManagerObserver> scoped_observer_;
base::RunLoop run_loop_;
DISALLOW_COPY_AND_ASSIGN(KioskSessionInitializedWaiter);
};
// Helper functions for CanConfigureNetwork mock.
class ScopedCanConfigureNetwork {
public:
ScopedCanConfigureNetwork(bool can_configure, bool needs_owner_auth)
: can_configure_(can_configure),
needs_owner_auth_(needs_owner_auth),
can_configure_network_callback_(
base::Bind(&ScopedCanConfigureNetwork::CanConfigureNetwork,
base::Unretained(this))),
needs_owner_auth_callback_(base::Bind(
&ScopedCanConfigureNetwork::NeedsOwnerAuthToConfigureNetwork,
base::Unretained(this))) {
AppLaunchController::SetCanConfigureNetworkCallbackForTesting(
&can_configure_network_callback_);
AppLaunchController::SetNeedOwnerAuthToConfigureNetworkCallbackForTesting(
&needs_owner_auth_callback_);
}
~ScopedCanConfigureNetwork() {
AppLaunchController::SetCanConfigureNetworkCallbackForTesting(NULL);
AppLaunchController::SetNeedOwnerAuthToConfigureNetworkCallbackForTesting(
NULL);
}
bool CanConfigureNetwork() { return can_configure_; }
bool NeedsOwnerAuthToConfigureNetwork() { return needs_owner_auth_; }
private:
bool can_configure_;
bool needs_owner_auth_;
AppLaunchController::ReturnBoolCallback can_configure_network_callback_;
AppLaunchController::ReturnBoolCallback needs_owner_auth_callback_;
DISALLOW_COPY_AND_ASSIGN(ScopedCanConfigureNetwork);
};
// Helper class to wait until a js condition becomes true.
class JsConditionWaiter {
public:
JsConditionWaiter(content::WebContents* web_contents, const std::string& js)
: web_contents_(web_contents), js_(js) {}
void Wait() {
if (CheckJs())
return;
base::RepeatingTimer check_timer;
check_timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(10), this,
&JsConditionWaiter::OnTimer);
runner_ = new content::MessageLoopRunner;
runner_->Run();
}
private:
bool CheckJs() {
bool result;
CHECK(content::ExecuteScriptAndExtractBool(
web_contents_,
"window.domAutomationController.send(!!(" + js_ + "));",
&result));
return result;
}
void OnTimer() {
DCHECK(runner_.get());
if (CheckJs())
runner_->Quit();
}
content::WebContents* web_contents_;
const std::string js_;
scoped_refptr<content::MessageLoopRunner> runner_;
DISALLOW_COPY_AND_ASSIGN(JsConditionWaiter);
};
class KioskFakeDiskMountManager : public file_manager::FakeDiskMountManager {
public:
KioskFakeDiskMountManager() {}
~KioskFakeDiskMountManager() override {}
void set_usb_mount_path(const std::string& usb_mount_path) {
usb_mount_path_ = usb_mount_path;
}
void MountUsbStick() {
DCHECK(!usb_mount_path_.empty());
MountPath(usb_mount_path_, "", "", chromeos::MOUNT_TYPE_DEVICE,
chromeos::MOUNT_ACCESS_MODE_READ_ONLY);
}
void UnMountUsbStick() {
DCHECK(!usb_mount_path_.empty());
UnmountPath(usb_mount_path_, UNMOUNT_OPTIONS_NONE,
disks::DiskMountManager::UnmountPathCallback());
}
private:
std::string usb_mount_path_;
DISALLOW_COPY_AND_ASSIGN(KioskFakeDiskMountManager);
};
class AppDataLoadWaiter : public KioskAppManagerObserver {
public:
AppDataLoadWaiter(KioskAppManager* manager,
const std::string& app_id,
const std::string& version)
: runner_(NULL),
manager_(manager),
wait_type_(WAIT_FOR_CRX_CACHE),
loaded_(false),
quit_(false),
app_id_(app_id),
version_(version) {
manager_->AddObserver(this);
}
~AppDataLoadWaiter() override { manager_->RemoveObserver(this); }
void Wait() {
wait_type_ = WAIT_FOR_CRX_CACHE;
if (quit_)
return;
runner_ = new content::MessageLoopRunner;
runner_->Run();
}
void WaitForAppData() {
wait_type_ = WAIT_FOR_APP_DATA;
if (quit_ || IsAppDataLoaded())
return;
runner_ = new content::MessageLoopRunner;
runner_->Run();
}
bool loaded() const { return loaded_; }
private:
enum WaitType {
WAIT_FOR_CRX_CACHE,
WAIT_FOR_APP_DATA,
};
// KioskAppManagerObserver overrides:
void OnKioskAppDataChanged(const std::string& app_id) override {
if (wait_type_ != WAIT_FOR_APP_DATA || app_id != app_id_ ||
!IsAppDataLoaded()) {
return;
}
loaded_ = true;
quit_ = true;
if (runner_.get())
runner_->Quit();
}
void OnKioskAppDataLoadFailure(const std::string& app_id) override {
if (wait_type_ != WAIT_FOR_APP_DATA || app_id != app_id_)
return;
loaded_ = false;
quit_ = true;
if (runner_.get())
runner_->Quit();
}
void OnKioskExtensionLoadedInCache(const std::string& app_id) override {
if (wait_type_ != WAIT_FOR_CRX_CACHE)
return;
std::string cached_version;
base::FilePath file_path;
if (!manager_->GetCachedCrx(app_id_, &file_path, &cached_version))
return;
if (version_ != cached_version)
return;
loaded_ = true;
quit_ = true;
if (runner_.get())
runner_->Quit();
}
void OnKioskExtensionDownloadFailed(const std::string& app_id) override {
if (wait_type_ != WAIT_FOR_CRX_CACHE)
return;
loaded_ = false;
quit_ = true;
if (runner_.get())
runner_->Quit();
}
bool IsAppDataLoaded() {
KioskAppManager::App app;
return manager_->GetApp(app_id_, &app) && !app.is_loading;
}
scoped_refptr<content::MessageLoopRunner> runner_;
KioskAppManager* manager_;
WaitType wait_type_;
bool loaded_;
bool quit_;
std::string app_id_;
std::string version_;
DISALLOW_COPY_AND_ASSIGN(AppDataLoadWaiter);
};
} // namespace
class KioskTest : public OobeBaseTest {
public:
KioskTest() : settings_helper_(false), fake_cws_(new FakeCWS) {
set_exit_when_last_browser_closes(false);
}
~KioskTest() override {}
protected:
void SetUp() override {
test_app_id_ = kTestKioskApp;
set_test_app_version("1.0.0");
set_test_crx_file(test_app_id() + ".crx");
needs_background_networking_ = true;
mock_user_manager_.reset(new MockUserManager);
ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(true);
AppLaunchController::SkipSplashWaitForTesting();
AppLaunchController::SetNetworkWaitForTesting(kTestNetworkTimeoutSeconds);
OobeBaseTest::SetUp();
}
void TearDown() override {
ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(false);
OobeBaseTest::TearDown();
}
void SetUpOnMainThread() override {
OobeBaseTest::SetUpOnMainThread();
// Needed to avoid showing Gaia screen instead of owner signin for
// consumer network down test cases.
StartupUtils::MarkDeviceRegistered(base::Closure());
settings_helper_.ReplaceProvider(kAccountsPrefDeviceLocalAccounts);
owner_settings_service_ = settings_helper_.CreateOwnerSettingsService(
ProfileManager::GetPrimaryUserProfile());
// Set up local cache for app update check.
extensions::browsertest_util::CreateAndInitializeLocalCache();
}
void TearDownOnMainThread() override {
settings_helper_.RestoreProvider();
AppLaunchController::SetNetworkTimeoutCallbackForTesting(NULL);
AppLaunchSigninScreen::SetUserManagerForTesting(NULL);
OobeBaseTest::TearDownOnMainThread();
// Clean up while main thread still runs.
// See http://crbug.com/176659.
KioskAppManager::Get()->CleanUp();
}
void SetUpCommandLine(base::CommandLine* command_line) override {
OobeBaseTest::SetUpCommandLine(command_line);
fake_cws_->Init(embedded_test_server());
if (use_consumer_kiosk_mode_)
command_line->AppendSwitch(switches::kEnableConsumerKiosk);
}
void LaunchApp(const std::string& app_id, bool diagnostic_mode) {
bool new_kiosk_ui = KioskAppMenuHandler::EnableNewKioskUI();
GetLoginUI()->CallJavascriptFunctionUnsafe(
new_kiosk_ui ? kLaunchAppForTestNewAPI : kLaunchAppForTestOldAPI,
base::Value(app_id), base::Value(diagnostic_mode));
}
void ReloadKioskApps() {
SetupTestAppUpdateCheck();
// Remove then add to ensure NOTIFICATION_KIOSK_APPS_LOADED fires.
KioskAppManager::Get()->RemoveApp(test_app_id_,
owner_settings_service_.get());
KioskAppManager::Get()->AddApp(test_app_id_, owner_settings_service_.get());
}
void FireKioskAppSettingsChanged() {
KioskAppManager::Get()->UpdateAppData();
}
void SetupTestAppUpdateCheck() {
if (!test_app_version().empty()) {
fake_cws_->SetUpdateCrx(test_app_id(), test_crx_file(),
test_app_version());
}
}
void ReloadAutolaunchKioskApps() {
SetupTestAppUpdateCheck();
KioskAppManager::Get()->AddApp(test_app_id_, owner_settings_service_.get());
KioskAppManager::Get()->SetAutoLaunchApp(test_app_id_,
owner_settings_service_.get());
}
void StartUIForAppLaunch() {
if (use_consumer_kiosk_mode_)
EnableConsumerKioskMode();
// Start UI
chromeos::WizardController::SkipPostLoginScreensForTesting();
chromeos::WizardController* wizard_controller =
chromeos::WizardController::default_controller();
if (wizard_controller) {
wizard_controller->SkipToLoginForTesting(LoginScreenContext());
OobeScreenWaiter(OobeScreen::SCREEN_GAIA_SIGNIN).Wait();
} else {
// No wizard and running with an existing profile and it should land
// on account picker when new kiosk UI is enabled. Otherwise, just
// wait for the login signal from Gaia.
if (KioskAppMenuHandler::EnableNewKioskUI())
OobeScreenWaiter(OobeScreen::SCREEN_ACCOUNT_PICKER).Wait();
else
OobeScreenWaiter(OobeScreen::SCREEN_GAIA_SIGNIN).Wait();
}
}
void PrepareAppLaunch() {
// Start UI
StartUIForAppLaunch();
// Wait for the Kiosk App configuration to reload.
content::WindowedNotificationObserver apps_loaded_signal(
chrome::NOTIFICATION_KIOSK_APPS_LOADED,
content::NotificationService::AllSources());
ReloadKioskApps();
apps_loaded_signal.Wait();
}
void StartAppLaunchFromLoginScreen(const base::Closure& network_setup_cb) {
PrepareAppLaunch();
if (!network_setup_cb.is_null())
network_setup_cb.Run();
LaunchApp(test_app_id(), false);
}
const extensions::Extension* GetInstalledApp() {
Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
return extensions::ExtensionSystem::Get(app_profile)
->extension_service()
->GetInstalledExtension(test_app_id_);
}
const base::Version& GetInstalledAppVersion() {
return GetInstalledApp()->version();
}
extensions::Manifest::Location GetInstalledAppLocation() {
return GetInstalledApp()->location();
}
void WaitForAppLaunchWithOptions(bool check_launch_data, bool terminate_app) {
ExtensionTestMessageListener launch_data_check_listener(
"launchData.isKioskSession = true", false);
// Wait for the Kiosk App to launch.
KioskSessionInitializedWaiter().Wait();
// Default profile switches to app profile after app is launched.
Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
ASSERT_TRUE(app_profile);
// Check ChromeOS preference is initialized.
EXPECT_TRUE(static_cast<ProfileImpl*>(app_profile)->chromeos_preferences_);
// Check installer status.
EXPECT_EQ(chromeos::KioskAppLaunchError::NONE,
chromeos::KioskAppLaunchError::Get());
// Check if the kiosk webapp is really installed for the default profile.
const extensions::Extension* app =
extensions::ExtensionSystem::Get(app_profile)
->extension_service()
->GetInstalledExtension(test_app_id_);
EXPECT_TRUE(app);
// App should appear with its window.
extensions::AppWindowRegistry* app_window_registry =
extensions::AppWindowRegistry::Get(app_profile);
extensions::AppWindow* window =
apps::AppWindowWaiter(app_window_registry, test_app_id_).Wait();
EXPECT_TRUE(window);
// Login screen should be gone or fading out.
LoginDisplayHost* login_display_host = LoginDisplayHost::default_host();
EXPECT_TRUE(
login_display_host == NULL ||
login_display_host->GetNativeWindow()->layer()->GetTargetOpacity() ==
0.0f);
// Terminate the app.
if (terminate_app)
window->GetBaseWindow()->Close();
// Wait until the app terminates if it is still running.
if (!app_window_registry->GetAppWindowsForApp(test_app_id_).empty())
content::RunMessageLoop();
// Check that the app had been informed that it is running in a kiosk
// session.
if (check_launch_data)
EXPECT_TRUE(launch_data_check_listener.was_satisfied());
}
void WaitForAppLaunchSuccess() {
WaitForAppLaunchWithOptions(true /* check_launch_data */,
true /* terminate_app */);
}
void WaitForAppLaunchNetworkTimeout() {
if (GetAppLaunchController()->network_wait_timedout())
return;
scoped_refptr<content::MessageLoopRunner> runner =
new content::MessageLoopRunner;
base::Closure callback =
base::Bind(&OnNetworkWaitTimedOut, runner->QuitClosure());
AppLaunchController::SetNetworkTimeoutCallbackForTesting(&callback);
runner->Run();
CHECK(GetAppLaunchController()->network_wait_timedout());
AppLaunchController::SetNetworkTimeoutCallbackForTesting(NULL);
}
void EnableConsumerKioskMode() {
bool locked = false;
scoped_refptr<content::MessageLoopRunner> runner =
new content::MessageLoopRunner;
KioskAppManager::Get()->EnableConsumerKioskAutoLaunch(base::Bind(
&ConsumerKioskModeAutoStartLockCheck, &locked, runner->QuitClosure()));
runner->Run();
EXPECT_TRUE(locked);
}
KioskAppManager::ConsumerKioskAutoLaunchStatus GetConsumerKioskModeStatus() {
KioskAppManager::ConsumerKioskAutoLaunchStatus status =
static_cast<KioskAppManager::ConsumerKioskAutoLaunchStatus>(-1);
scoped_refptr<content::MessageLoopRunner> runner =
new content::MessageLoopRunner;
KioskAppManager::Get()->GetConsumerKioskAutoLaunchStatus(base::Bind(
&ConsumerKioskAutoLaunchStatusCheck, &status, runner->QuitClosure()));
runner->Run();
CHECK_NE(status,
static_cast<KioskAppManager::ConsumerKioskAutoLaunchStatus>(-1));
return status;
}
void RunAppLaunchNetworkDownTest() {
mock_user_manager()->SetActiveUser(test_owner_account_id_);
AppLaunchSigninScreen::SetUserManagerForTesting(mock_user_manager());
// Mock network could be configured with owner's password.
ScopedCanConfigureNetwork can_configure_network(true, true);
// Start app launch and wait for network connectivity timeout.
StartAppLaunchFromLoginScreen(SimulateNetworkOfflineClosure());
OobeScreenWaiter splash_waiter(OobeScreen::SCREEN_APP_LAUNCH_SPLASH);
splash_waiter.Wait();
WaitForAppLaunchNetworkTimeout();
// Configure network link should be visible.
JsExpect("$('splash-config-network').hidden == false");
// Set up fake user manager with an owner for the test.
LoginDisplayHost::default_host()->GetOobeUI()->ShowOobeUI(false);
// Configure network should bring up lock screen for owner.
OobeScreenWaiter lock_screen_waiter(OobeScreen::SCREEN_ACCOUNT_PICKER);
static_cast<AppLaunchSplashScreenView::Delegate*>(GetAppLaunchController())
->OnConfigureNetwork();
lock_screen_waiter.Wait();
// There should be only one owner pod on this screen.
JsExpect("$('pod-row').alwaysFocusSinglePod");
// A network error screen should be shown after authenticating.
OobeScreenWaiter error_screen_waiter(OobeScreen::SCREEN_ERROR_MESSAGE);
static_cast<AppLaunchSigninScreen::Delegate*>(GetAppLaunchController())
->OnOwnerSigninSuccess();
error_screen_waiter.Wait();
ASSERT_TRUE(GetAppLaunchController()->showing_network_dialog());
SimulateNetworkOnline();
WaitForAppLaunchSuccess();
}
AppLaunchController* GetAppLaunchController() {
return LoginDisplayHost::default_host()->GetAppLaunchController();
}
MockUserManager* mock_user_manager() { return mock_user_manager_.get(); }
void set_test_app_id(const std::string& test_app_id) {
test_app_id_ = test_app_id;
}
const std::string& test_app_id() const { return test_app_id_; }
void set_test_app_version(const std::string& version) {
test_app_version_ = version;
}
const std::string& test_app_version() const { return test_app_version_; }
void set_test_crx_file(const std::string& filename) {
test_crx_file_ = filename;
}
const std::string& test_crx_file() const { return test_crx_file_; }
FakeCWS* fake_cws() { return fake_cws_.get(); }
void set_use_consumer_kiosk_mode(bool use) { use_consumer_kiosk_mode_ = use; }
ScopedCrosSettingsTestHelper settings_helper_;
std::unique_ptr<FakeOwnerSettingsService> owner_settings_service_;
const AccountId test_owner_account_id_ =
AccountId::FromUserEmail(kTestOwnerEmail);
private:
bool use_consumer_kiosk_mode_ = true;
std::string test_app_id_;
std::string test_app_version_;
std::string test_crx_file_;
std::unique_ptr<FakeCWS> fake_cws_;
std::unique_ptr<MockUserManager> mock_user_manager_;
DISALLOW_COPY_AND_ASSIGN(KioskTest);
};
IN_PROC_BROWSER_TEST_F(KioskTest, InstallAndLaunchApp) {
StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
WaitForAppLaunchSuccess();
KioskAppManager::App app;
ASSERT_TRUE(KioskAppManager::Get()->GetApp(test_app_id(), &app));
EXPECT_FALSE(app.was_auto_launched_with_zero_delay);
EXPECT_EQ(extensions::Manifest::EXTERNAL_PREF, GetInstalledAppLocation());
}
IN_PROC_BROWSER_TEST_F(KioskTest, ZoomSupport) {
ExtensionTestMessageListener app_window_loaded_listener("appWindowLoaded",
false);
StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
app_window_loaded_listener.WaitUntilSatisfied();
Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
ASSERT_TRUE(app_profile);
extensions::AppWindowRegistry* app_window_registry =
extensions::AppWindowRegistry::Get(app_profile);
extensions::AppWindow* window =
apps::AppWindowWaiter(app_window_registry, test_app_id()).Wait();
ASSERT_TRUE(window);
// Gets the original width of the app window.
int original_width;
EXPECT_TRUE(content::ExecuteScriptAndExtractInt(
window->web_contents(),
"window.domAutomationController.send(window.innerWidth);",
&original_width));
native_app_window::NativeAppWindowViews* native_app_window_views =
static_cast<native_app_window::NativeAppWindowViews*>(
window->GetBaseWindow());
ui::AcceleratorTarget* accelerator_target =
static_cast<ui::AcceleratorTarget*>(native_app_window_views);
// Zoom in. Text is bigger and content window width becomes smaller.
accelerator_target->AcceleratorPressed(
ui::Accelerator(ui::VKEY_ADD, ui::EF_CONTROL_DOWN));
int width_zoomed_in;
EXPECT_TRUE(content::ExecuteScriptAndExtractInt(
window->web_contents(),
"window.domAutomationController.send(window.innerWidth);",
&width_zoomed_in));
DCHECK_LT(width_zoomed_in, original_width);
// Go back to normal. Window width is restored.
accelerator_target->AcceleratorPressed(
ui::Accelerator(ui::VKEY_0, ui::EF_CONTROL_DOWN));
int width_zoom_normal;
EXPECT_TRUE(content::ExecuteScriptAndExtractInt(
window->web_contents(),
"window.domAutomationController.send(window.innerWidth);",
&width_zoom_normal));
DCHECK_EQ(width_zoom_normal, original_width);
// Zoom out. Text is smaller and content window width becomes larger.
accelerator_target->AcceleratorPressed(
ui::Accelerator(ui::VKEY_SUBTRACT, ui::EF_CONTROL_DOWN));
int width_zoomed_out;
EXPECT_TRUE(content::ExecuteScriptAndExtractInt(
window->web_contents(),
"window.domAutomationController.send(window.innerWidth);",
&width_zoomed_out));
DCHECK_GT(width_zoomed_out, original_width);
// Terminate the app.
window->GetBaseWindow()->Close();
content::RunAllPendingInMessageLoop();
}
IN_PROC_BROWSER_TEST_F(KioskTest, NotSignedInWithGAIAAccount) {
// Tests that the kiosk session is not considered to be logged in with a GAIA
// account.
StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
WaitForAppLaunchSuccess();
EXPECT_EQ(extensions::Manifest::EXTERNAL_PREF, GetInstalledAppLocation());
Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
ASSERT_TRUE(app_profile);
EXPECT_FALSE(
SigninManagerFactory::GetForProfile(app_profile)->IsAuthenticated());
}
IN_PROC_BROWSER_TEST_F(KioskTest, PRE_LaunchAppNetworkDown) {
// Tests the network down case for the initial app download and launch.
RunAppLaunchNetworkDownTest();
}
IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppNetworkDown) {
// Tests the network down case for launching an existing app that is
// installed in PRE_LaunchAppNetworkDown.
RunAppLaunchNetworkDownTest();
}
// Times out in MSAN: https://crbug.com/811379
#if defined(MEMORY_SANITIZER)
#define MAYBE_LaunchAppWithNetworkConfigAccelerator \
DISABLED_LaunchAppWithNetworkConfigAccelerator
#else
#define MAYBE_LaunchAppWithNetworkConfigAccelerator \
LaunchAppWithNetworkConfigAccelerator
#endif
IN_PROC_BROWSER_TEST_F(KioskTest, MAYBE_LaunchAppWithNetworkConfigAccelerator) {
ScopedCanConfigureNetwork can_configure_network(true, false);
// Block app loading until the network screen is shown.
AppLaunchController::SetBlockAppLaunchForTesting(true);
// Start app launch and wait for network connectivity timeout.
StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
OobeScreenWaiter splash_waiter(OobeScreen::SCREEN_APP_LAUNCH_SPLASH);
splash_waiter.Wait();
// A network error screen should be shown after authenticating.
OobeScreenWaiter error_screen_waiter(OobeScreen::SCREEN_ERROR_MESSAGE);
// Simulate Ctrl+Alt+N accelerator.
GetLoginUI()->CallJavascriptFunctionUnsafe(
"cr.ui.Oobe.handleAccelerator", base::Value("app_launch_network_config"));
error_screen_waiter.Wait();
ASSERT_TRUE(GetAppLaunchController()->showing_network_dialog());
// Continue button should be visible since we are online.
JsExpect("$('continue-network-config-btn').hidden == false");
// Let app launching resume.
AppLaunchController::SetBlockAppLaunchForTesting(false);
// Click on [Continue] button.
ASSERT_TRUE(content::ExecuteScript(
GetLoginUI()->GetWebContents(),
"(function() {"
"var e = new Event('click');"
"$('continue-network-config-btn').dispatchEvent(e);"
"})();"));
WaitForAppLaunchSuccess();
}
IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppNetworkDownConfigureNotAllowed) {
// Mock network could not be configured.
ScopedCanConfigureNetwork can_configure_network(false, true);
// Start app launch and wait for network connectivity timeout.
StartAppLaunchFromLoginScreen(SimulateNetworkOfflineClosure());
OobeScreenWaiter splash_waiter(OobeScreen::SCREEN_APP_LAUNCH_SPLASH);
splash_waiter.Wait();
WaitForAppLaunchNetworkTimeout();
// Configure network link should not be visible.
JsExpect("$('splash-config-network').hidden == true");
// Network becomes online and app launch is resumed.
SimulateNetworkOnline();
WaitForAppLaunchSuccess();
}
// http://crbug.com/543332
IN_PROC_BROWSER_TEST_F(KioskTest, DISABLED_LaunchAppNetworkPortal) {
// Mock network could be configured without the owner password.
ScopedCanConfigureNetwork can_configure_network(true, false);
// Start app launch with network portal state.
StartAppLaunchFromLoginScreen(SimulateNetworkPortalClosure());
OobeScreenWaiter(OobeScreen::SCREEN_APP_LAUNCH_SPLASH)
.WaitNoAssertCurrentScreen();
WaitForAppLaunchNetworkTimeout();
// Network error should show up automatically since this test does not
// require owner auth to configure network.
OobeScreenWaiter(OobeScreen::SCREEN_ERROR_MESSAGE).Wait();
ASSERT_TRUE(GetAppLaunchController()->showing_network_dialog());
SimulateNetworkOnline();
WaitForAppLaunchSuccess();
}
IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppUserCancel) {
// Make fake_cws_ return empty update response.
set_test_app_version("");
OobeScreenWaiter splash_waiter(OobeScreen::SCREEN_APP_LAUNCH_SPLASH);
StartAppLaunchFromLoginScreen(SimulateNetworkOfflineClosure());
splash_waiter.Wait();
settings_helper_.SetBoolean(
kAccountsPrefDeviceLocalAccountAutoLoginBailoutEnabled, true);
content::WindowedNotificationObserver signal(
chrome::NOTIFICATION_APP_TERMINATING,
content::NotificationService::AllSources());
GetLoginUI()->CallJavascriptFunctionUnsafe("cr.ui.Oobe.handleAccelerator",
base::Value("app_launch_bailout"));
signal.Wait();
EXPECT_EQ(chromeos::KioskAppLaunchError::USER_CANCEL,
chromeos::KioskAppLaunchError::Get());
}
IN_PROC_BROWSER_TEST_F(KioskTest, LaunchInDiagnosticMode) {
PrepareAppLaunch();
SimulateNetworkOnline();
LaunchApp(kTestKioskApp, true);
content::WebContents* login_contents = GetLoginUI()->GetWebContents();
bool new_kiosk_ui = KioskAppMenuHandler::EnableNewKioskUI();
JsConditionWaiter(login_contents, new_kiosk_ui ? kCheckDiagnosticModeNewAPI
: kCheckDiagnosticModeOldAPI)
.Wait();
std::string diagnosticMode(new_kiosk_ui ?
kCheckDiagnosticModeNewAPI : kCheckDiagnosticModeOldAPI);
ASSERT_TRUE(content::ExecuteScript(
login_contents,
"(function() {"
"var e = new Event('click');" +
diagnosticMode + "."
"okButton_.dispatchEvent(e);"
"})();"));
WaitForAppLaunchSuccess();
EXPECT_EQ(extensions::Manifest::EXTERNAL_PREF, GetInstalledAppLocation());
}
IN_PROC_BROWSER_TEST_F(KioskTest, AutolaunchWarningCancel) {
EnableConsumerKioskMode();
chromeos::WizardController::SkipPostLoginScreensForTesting();
chromeos::WizardController* wizard_controller =
chromeos::WizardController::default_controller();
CHECK(wizard_controller);
// Start login screen after configuring auto launch app since the warning
// is triggered when switching to login screen.
wizard_controller->AdvanceToScreen(OobeScreen::SCREEN_OOBE_NETWORK);
ReloadAutolaunchKioskApps();
EXPECT_FALSE(KioskAppManager::Get()->GetAutoLaunchApp().empty());
EXPECT_FALSE(KioskAppManager::Get()->IsAutoLaunchEnabled());
wizard_controller->SkipToLoginForTesting(LoginScreenContext());
// Wait for the auto launch warning come up.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
content::NotificationService::AllSources())
.Wait();
GetLoginUI()->CallJavascriptFunctionUnsafe(
"login.AutolaunchScreen.confirmAutoLaunchForTesting", base::Value(false));
// Wait for the auto launch warning to go away.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_COMPLETED,
content::NotificationService::AllSources())
.Wait();
EXPECT_FALSE(KioskAppManager::Get()->IsAutoLaunchEnabled());
}
IN_PROC_BROWSER_TEST_F(KioskTest, AutolaunchWarningConfirm) {
EnableConsumerKioskMode();
chromeos::WizardController::SkipPostLoginScreensForTesting();
chromeos::WizardController* wizard_controller =
chromeos::WizardController::default_controller();
CHECK(wizard_controller);
// Start login screen after configuring auto launch app since the warning
// is triggered when switching to login screen.
wizard_controller->AdvanceToScreen(OobeScreen::SCREEN_OOBE_NETWORK);
ReloadAutolaunchKioskApps();
EXPECT_FALSE(KioskAppManager::Get()->GetAutoLaunchApp().empty());
EXPECT_FALSE(KioskAppManager::Get()->IsAutoLaunchEnabled());
wizard_controller->SkipToLoginForTesting(LoginScreenContext());
// Wait for the auto launch warning come up.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
content::NotificationService::AllSources())
.Wait();
GetLoginUI()->CallJavascriptFunctionUnsafe(
"login.AutolaunchScreen.confirmAutoLaunchForTesting", base::Value(true));
// Wait for the auto launch warning to go away.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_COMPLETED,
content::NotificationService::AllSources())
.Wait();
EXPECT_FALSE(KioskAppManager::Get()->GetAutoLaunchApp().empty());
EXPECT_TRUE(KioskAppManager::Get()->IsAutoLaunchEnabled());
WaitForAppLaunchSuccess();
KioskAppManager::App app;
ASSERT_TRUE(KioskAppManager::Get()->GetApp(test_app_id(), &app));
EXPECT_TRUE(app.was_auto_launched_with_zero_delay);
EXPECT_EQ(extensions::Manifest::EXTERNAL_PREF, GetInstalledAppLocation());
}
IN_PROC_BROWSER_TEST_F(KioskTest, KioskEnableCancel) {
chromeos::WizardController::SkipPostLoginScreensForTesting();
chromeos::WizardController* wizard_controller =
chromeos::WizardController::default_controller();
CHECK(wizard_controller);
// Check Kiosk mode status.
EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE,
GetConsumerKioskModeStatus());
// Wait for the login UI to come up and switch to the kiosk_enable screen.
wizard_controller->SkipToLoginForTesting(LoginScreenContext());
OobeScreenWaiter(OobeScreen::SCREEN_GAIA_SIGNIN).Wait();
GetLoginUI()->CallJavascriptFunctionUnsafe("cr.ui.Oobe.handleAccelerator",
base::Value("kiosk_enable"));
// Wait for the kiosk_enable screen to show and cancel the screen.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_VISIBLE,
content::NotificationService::AllSources())
.Wait();
GetLoginUI()->CallJavascriptFunctionUnsafe(
"login.KioskEnableScreen.enableKioskForTesting", base::Value(false));
// Wait for the kiosk_enable screen to disappear.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_COMPLETED,
content::NotificationService::AllSources())
.Wait();
// Check that the status still says configurable.
EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE,
GetConsumerKioskModeStatus());
}
IN_PROC_BROWSER_TEST_F(KioskTest, KioskEnableConfirmed) {
// Start UI, find menu entry for this app and launch it.
chromeos::WizardController::SkipPostLoginScreensForTesting();
chromeos::WizardController* wizard_controller =
chromeos::WizardController::default_controller();
CHECK(wizard_controller);
// Check Kiosk mode status.
EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE,
GetConsumerKioskModeStatus());
// Wait for the login UI to come up and switch to the kiosk_enable screen.
wizard_controller->SkipToLoginForTesting(LoginScreenContext());
OobeScreenWaiter(OobeScreen::SCREEN_GAIA_SIGNIN).Wait();
GetLoginUI()->CallJavascriptFunctionUnsafe("cr.ui.Oobe.handleAccelerator",
base::Value("kiosk_enable"));
// Wait for the kiosk_enable screen to show and cancel the screen.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_VISIBLE,
content::NotificationService::AllSources())
.Wait();
GetLoginUI()->CallJavascriptFunctionUnsafe(
"login.KioskEnableScreen.enableKioskForTesting", base::Value(true));
// Wait for the signal that indicates Kiosk Mode is enabled.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_ENABLED,
content::NotificationService::AllSources())
.Wait();
EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_ENABLED,
GetConsumerKioskModeStatus());
}
IN_PROC_BROWSER_TEST_F(KioskTest, KioskEnableAfter2ndSigninScreen) {
chromeos::WizardController::SkipPostLoginScreensForTesting();
chromeos::WizardController* wizard_controller =
chromeos::WizardController::default_controller();
CHECK(wizard_controller);
// Check Kiosk mode status.
EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE,
GetConsumerKioskModeStatus());
// Wait for the login UI to come up and switch to the kiosk_enable screen.
wizard_controller->SkipToLoginForTesting(LoginScreenContext());
OobeScreenWaiter(OobeScreen::SCREEN_GAIA_SIGNIN).Wait();
GetLoginUI()->CallJavascriptFunctionUnsafe("cr.ui.Oobe.handleAccelerator",
base::Value("kiosk_enable"));
// Wait for the kiosk_enable screen to show and cancel the screen.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_VISIBLE,
content::NotificationService::AllSources())
.Wait();
GetLoginUI()->CallJavascriptFunctionUnsafe(
"login.KioskEnableScreen.enableKioskForTesting", base::Value(false));
// Wait for the kiosk_enable screen to disappear.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_COMPLETED,
content::NotificationService::AllSources())
.Wait();
// Show signin screen again.
LoginDisplayHost::default_host()->StartSignInScreen(LoginScreenContext());
OobeScreenWaiter(OobeScreen::SCREEN_GAIA_SIGNIN).Wait();
// Show kiosk enable screen again.
GetLoginUI()->CallJavascriptFunctionUnsafe("cr.ui.Oobe.handleAccelerator",
base::Value("kiosk_enable"));
// And it should show up.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_VISIBLE,
content::NotificationService::AllSources())
.Wait();
}
// crbug.com/766169
#if defined(ADDRESS_SANITIZER)
#define MAYBE_DoNotLaunchWhenUntrusted DISABLED_DoNotLaunchWhenUntrusted
#else
#define MAYBE_DoNotLaunchWhenUntrusted DoNotLaunchWhenUntrusted
#endif
IN_PROC_BROWSER_TEST_F(KioskTest, MAYBE_DoNotLaunchWhenUntrusted) {
PrepareAppLaunch();
SimulateNetworkOnline();
// Make cros settings untrusted.
settings_helper_.SetTrustedStatus(
CrosSettingsProvider::PERMANENTLY_UNTRUSTED);
// Check that the attempt to start a kiosk app fails with an error.
LaunchApp(test_app_id(), false);
bool ignored = false;
EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
GetLoginUI()->GetWebContents(),
"if (cr.ui.Oobe.getInstance().errorMessageWasShownForTesting_) {"
" window.domAutomationController.send(true);"
"} else {"
" cr.ui.Oobe.showSignInError = function("
" loginAttempts, message, link, helpId) {"
" window.domAutomationController.send(true);"
" };"
"}",
&ignored));
}
// crbug.com/766169
#if defined(ADDRESS_SANITIZER)
#define MAYBE_NoConsumerAutoLaunchWhenUntrusted \
DISABLED_NoConsumerAutoLaunchWhenUntrusted
#else
#define MAYBE_NoConsumerAutoLaunchWhenUntrusted \
NoConsumerAutoLaunchWhenUntrusted
#endif
// Verifies that a consumer device does not auto-launch kiosk mode when cros
// settings are untrusted.
IN_PROC_BROWSER_TEST_F(KioskTest, MAYBE_NoConsumerAutoLaunchWhenUntrusted) {
EnableConsumerKioskMode();
// Wait for and confirm the auto-launch warning.
chromeos::WizardController::SkipPostLoginScreensForTesting();
chromeos::WizardController* wizard_controller =
chromeos::WizardController::default_controller();
ASSERT_TRUE(wizard_controller);
wizard_controller->AdvanceToScreen(OobeScreen::SCREEN_OOBE_NETWORK);
ReloadAutolaunchKioskApps();
wizard_controller->SkipToLoginForTesting(LoginScreenContext());
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
content::NotificationService::AllSources())
.Wait();
GetLoginUI()->CallJavascriptFunctionUnsafe(
"login.AutolaunchScreen.confirmAutoLaunchForTesting", base::Value(true));
// Make cros settings untrusted.
settings_helper_.SetTrustedStatus(
CrosSettingsProvider::PERMANENTLY_UNTRUSTED);
// Check that the attempt to auto-launch a kiosk app fails with an error.
OobeScreenWaiter(OobeScreen::SCREEN_ERROR_MESSAGE).Wait();
}
// Verifies available volumes for kiosk apps in kiosk session.
IN_PROC_BROWSER_TEST_F(KioskTest, GetVolumeList) {
set_test_app_id(kTestGetVolumeListKioskApp);
set_test_app_version("0.1");
set_test_crx_file(test_app_id() + ".crx");
extensions::ResultCatcher catcher;
StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
}
// Verifies that an enterprise device does not auto-launch kiosk mode when cros
// settings are untrusted.
IN_PROC_BROWSER_TEST_F(KioskTest, NoEnterpriseAutoLaunchWhenUntrusted) {
PrepareAppLaunch();
SimulateNetworkOnline();
// Make cros settings untrusted.
settings_helper_.SetTrustedStatus(
CrosSettingsProvider::PERMANENTLY_UNTRUSTED);
// Trigger the code that handles auto-launch on enterprise devices. This would
// normally be called from ShowLoginWizard(), which runs so early that it is
// not possible to inject an auto-launch policy before it runs.
LoginDisplayHost* login_display_host = LoginDisplayHost::default_host();
ASSERT_TRUE(login_display_host);
login_display_host->StartAppLaunch(test_app_id(), false, true);
// Check that no launch has started.
EXPECT_FALSE(login_display_host->GetAppLaunchController());
}
class KioskUpdateTest : public KioskTest {
public:
KioskUpdateTest() {}
~KioskUpdateTest() override {}
struct TestAppInfo {
std::string id;
std::string version;
std::string crx_filename;
extensions::Manifest::Type type;
TestAppInfo() {}
TestAppInfo(const std::string& id,
const std::string& version,
const std::string& crx_filename,
extensions::Manifest::Type type)
: id(id), version(version), crx_filename(crx_filename), type(type) {}
~TestAppInfo() {}
};
protected:
void SetUp() override {
fake_disk_mount_manager_ = new KioskFakeDiskMountManager();
disks::DiskMountManager::InitializeForTesting(fake_disk_mount_manager_);
KioskTest::SetUp();
}
void TearDown() override {
disks::DiskMountManager::Shutdown();
KioskTest::TearDown();
}
void SetUpOnMainThread() override {
// For update tests, we cache the app in the PRE part, and then we load it
// in the test, so we need to both store the apps list on teardown (so that
// the app manager would accept existing files in its extension cache on the
// next startup) and copy the list to our stub settings provider as well.
settings_helper_.CopyStoredValue(kAccountsPrefDeviceLocalAccounts);
KioskTest::SetUpOnMainThread();
}
void TearDownOnMainThread() override {
settings_helper_.StoreCachedDeviceSetting(kAccountsPrefDeviceLocalAccounts);
KioskTest::TearDownOnMainThread();
}
void PreCacheApp(const std::string& app_id,
const std::string& version,
const std::string& crx_file) {
set_test_app_id(app_id);
set_test_app_version(version);
set_test_crx_file(crx_file);
KioskAppManager* manager = KioskAppManager::Get();
AppDataLoadWaiter waiter(manager, app_id, version);
ReloadKioskApps();
waiter.Wait();
EXPECT_TRUE(waiter.loaded());
std::string cached_version;
base::FilePath file_path;
EXPECT_TRUE(manager->GetCachedCrx(app_id, &file_path, &cached_version));
EXPECT_EQ(version, cached_version);
}
void UpdateExternalCache(const std::string& version,
const std::string& crx_file) {
set_test_app_version(version);
set_test_crx_file(crx_file);
SetupTestAppUpdateCheck();
KioskAppManager* manager = KioskAppManager::Get();
AppDataLoadWaiter waiter(manager, test_app_id(), version);
KioskAppManager::Get()->UpdateExternalCache();
waiter.Wait();
EXPECT_TRUE(waiter.loaded());
std::string cached_version;
base::FilePath file_path;
EXPECT_TRUE(
manager->GetCachedCrx(test_app_id(), &file_path, &cached_version));
EXPECT_EQ(version, cached_version);
}
void SetupFakeDiskMountManagerMountPath(const std::string& mount_path) {
base::FilePath test_data_dir;
PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
test_data_dir = test_data_dir.AppendASCII(mount_path);
fake_disk_mount_manager_->set_usb_mount_path(test_data_dir.value());
}
void SimulateUpdateAppFromUsbStick(const std::string& usb_mount_path,
bool* app_update_notified,
bool* update_success) {
SetupFakeDiskMountManagerMountPath(usb_mount_path);
KioskAppExternalUpdateWaiter waiter(KioskAppManager::Get(), test_app_id());
fake_disk_mount_manager_->MountUsbStick();
waiter.Wait();
fake_disk_mount_manager_->UnMountUsbStick();
*update_success = waiter.update_success();
*app_update_notified = waiter.app_update_notified();
}
void PreCacheAndLaunchApp(const std::string& app_id,
const std::string& version,
const std::string& crx_file) {
set_test_app_id(app_id);
set_test_app_version(version);
set_test_crx_file(crx_file);
PrepareAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ(version, GetInstalledAppVersion().GetString());
}
void LaunchKioskWithSecondaryApps(
const TestAppInfo& primary_app,
const std::vector<TestAppInfo>& secondary_apps) {
// Pre-cache the primary app.
PreCacheApp(primary_app.id, primary_app.version, primary_app.crx_filename);
set_test_app_id(primary_app.id);
fake_cws()->SetNoUpdate(primary_app.id);
for (const auto& app : secondary_apps) {
fake_cws()->SetUpdateCrx(app.id, app.crx_filename, app.version);
}
// Launch the primary app.
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchWithOptions(false, true);
// Verify the primary app and the secondary apps are all installed.
EXPECT_TRUE(IsAppInstalled(primary_app.id, primary_app.version));
for (const auto& app : secondary_apps) {
EXPECT_TRUE(IsAppInstalled(app.id, app.version));
EXPECT_EQ(GetAppType(app.id), app.type);
}
}
void LaunchTestKioskAppWithTwoSecondaryApps() {
TestAppInfo primary_app(kTestPrimaryKioskApp, "1.0.0",
std::string(kTestPrimaryKioskApp) + "-1.0.0.crx",
extensions::Manifest::TYPE_PLATFORM_APP);
std::vector<TestAppInfo> secondary_apps;
TestAppInfo secondary_app_1(kTestSecondaryApp1, "1.0.0",
std::string(kTestSecondaryApp1) + "-1.0.0.crx",
extensions::Manifest::TYPE_PLATFORM_APP);
secondary_apps.push_back(secondary_app_1);
TestAppInfo secondary_app_2(kTestSecondaryApp2, "1.0.0",
std::string(kTestSecondaryApp2) + "-1.0.0.crx",
extensions::Manifest::TYPE_PLATFORM_APP);
secondary_apps.push_back(secondary_app_2);
LaunchKioskWithSecondaryApps(primary_app, secondary_apps);
}
void LaunchTestKioskAppWithSeconadayExtension() {
TestAppInfo primary_app(kTestPrimaryKioskApp, "24.0.0",
std::string(kTestPrimaryKioskApp) + "-24.0.0.crx",
extensions::Manifest::TYPE_PLATFORM_APP);
std::vector<TestAppInfo> secondary_apps;
TestAppInfo secondary_extension(
kTestSecondaryExtension, "1.0.0",
std::string(kTestSecondaryExtension) + "-1.0.0.crx",
extensions::Manifest::TYPE_EXTENSION);
secondary_apps.push_back(secondary_extension);
LaunchKioskWithSecondaryApps(primary_app, secondary_apps);
}
void LaunchAppWithSharedModuleAndSecondaryApp() {
TestAppInfo primary_app(
kTestSharedModulePrimaryApp, "1.0.0",
std::string(kTestSharedModulePrimaryApp) + "-1.0.0.crx",
extensions::Manifest::TYPE_PLATFORM_APP);
std::vector<TestAppInfo> secondary_apps;
TestAppInfo secondary_app(kTestSecondaryApp, "1.0.0",
std::string(kTestSecondaryApp) + "-1.0.0.crx",
extensions::Manifest::TYPE_PLATFORM_APP);
secondary_apps.push_back(secondary_app);
// Setting up FakeCWS for shared module is the same for shared module as
// for kiosk secondary apps.
TestAppInfo shared_module(kTestSharedModuleId, "1.0.0",
std::string(kTestSharedModuleId) + "-1.0.0.crx",
extensions::Manifest::TYPE_SHARED_MODULE);
secondary_apps.push_back(shared_module);
LaunchKioskWithSecondaryApps(primary_app, secondary_apps);
EXPECT_TRUE(IsAppInstalled(shared_module.id, shared_module.version));
}
void LaunchAppWithSharedModule() {
TestAppInfo primary_app(
kTestSharedModulePrimaryApp, "2.0.0",
std::string(kTestSharedModulePrimaryApp) + "-2.0.0.crx",
extensions::Manifest::TYPE_PLATFORM_APP);
std::vector<TestAppInfo> secondary_apps;
// Setting up FakeCWS for shared module is the same for shared module as
// for kiosk secondary apps.
TestAppInfo shared_module(kTestSharedModuleId, "1.0.0",
std::string(kTestSharedModuleId) + "-1.0.0.crx",
extensions::Manifest::TYPE_SHARED_MODULE);
secondary_apps.push_back(shared_module);
LaunchKioskWithSecondaryApps(primary_app, secondary_apps);
}
bool PrimaryAppUpdateIsPending() const {
Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
return !!extensions::ExtensionSystem::Get(app_profile)
->extension_service()
->GetPendingExtensionUpdate(test_app_id());
}
private:
class KioskAppExternalUpdateWaiter : public KioskAppManagerObserver {
public:
KioskAppExternalUpdateWaiter(KioskAppManager* manager,
const std::string& app_id)
: runner_(NULL),
manager_(manager),
app_id_(app_id),
quit_(false),
update_success_(false),
app_update_notified_(false) {
manager_->AddObserver(this);
}
~KioskAppExternalUpdateWaiter() override { manager_->RemoveObserver(this); }
void Wait() {
if (quit_)
return;
runner_ = new content::MessageLoopRunner;
runner_->Run();
}
bool update_success() const { return update_success_; }
bool app_update_notified() const { return app_update_notified_; }
private:
// KioskAppManagerObserver overrides:
void OnKioskAppCacheUpdated(const std::string& app_id) override {
if (app_id_ != app_id)
return;
app_update_notified_ = true;
}
void OnKioskAppExternalUpdateComplete(bool success) override {
quit_ = true;
update_success_ = success;
if (runner_.get())
runner_->Quit();
}
scoped_refptr<content::MessageLoopRunner> runner_;
KioskAppManager* manager_;
const std::string app_id_;
bool quit_;
bool update_success_;
bool app_update_notified_;
DISALLOW_COPY_AND_ASSIGN(KioskAppExternalUpdateWaiter);
};
// Owned by DiskMountManager.
KioskFakeDiskMountManager* fake_disk_mount_manager_;
DISALLOW_COPY_AND_ASSIGN(KioskUpdateTest);
};
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchOfflineEnabledAppNoNetwork) {
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "1.0.0",
std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchOfflineEnabledAppNoNetwork) {
set_test_app_id(kTestOfflineEnabledKioskApp);
StartUIForAppLaunch();
SimulateNetworkOffline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
EXPECT_EQ(extensions::Manifest::EXTERNAL_PREF, GetInstalledAppLocation());
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
PRE_LaunchCachedOfflineEnabledAppNoNetwork) {
PreCacheApp(kTestOfflineEnabledKioskApp, "1.0.0",
std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
LaunchCachedOfflineEnabledAppNoNetwork) {
set_test_app_id(kTestOfflineEnabledKioskApp);
EXPECT_TRUE(
KioskAppManager::Get()->HasCachedCrx(kTestOfflineEnabledKioskApp));
StartUIForAppLaunch();
SimulateNetworkOffline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
EXPECT_EQ(extensions::Manifest::EXTERNAL_PREF, GetInstalledAppLocation());
}
// Network offline, app v1.0 has run before, has cached v2.0 crx and v2.0 should
// be installed and launched during next launch.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
PRE_LaunchCachedNewVersionOfflineEnabledAppNoNetwork) {
// Install and launch v1 app.
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "1.0.0",
std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
// Update cache for v2 app.
UpdateExternalCache("2.0.0",
std::string(kTestOfflineEnabledKioskApp) + ".crx");
// The installed app is still in v1.
EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
LaunchCachedNewVersionOfflineEnabledAppNoNetwork) {
set_test_app_id(kTestOfflineEnabledKioskApp);
EXPECT_TRUE(KioskAppManager::Get()->HasCachedCrx(test_app_id()));
StartUIForAppLaunch();
SimulateNetworkOffline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
// v2 app should have been installed.
EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
EXPECT_EQ(extensions::Manifest::EXTERNAL_PREF, GetInstalledAppLocation());
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchOfflineEnabledAppNoUpdate) {
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "1.0.0",
std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchOfflineEnabledAppNoUpdate) {
set_test_app_id(kTestOfflineEnabledKioskApp);
fake_cws()->SetNoUpdate(test_app_id());
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
EXPECT_EQ(extensions::Manifest::EXTERNAL_PREF, GetInstalledAppLocation());
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchOfflineEnabledAppHasUpdate) {
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "1.0.0",
std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchOfflineEnabledAppHasUpdate) {
set_test_app_id(kTestOfflineEnabledKioskApp);
fake_cws()->SetUpdateCrx(test_app_id(),
"ajoggoflpgplnnjkjamcmbepjdjdnpdp.crx", "2.0.0");
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
EXPECT_EQ(extensions::Manifest::EXTERNAL_PREF, GetInstalledAppLocation());
}
// Pre-cache v1 kiosk app, then launch the app without network,
// plug in usb stick with a v2 app for offline updating.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_UsbStickUpdateAppNoNetwork) {
PreCacheApp(kTestOfflineEnabledKioskApp, "1.0.0",
std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
set_test_app_id(kTestOfflineEnabledKioskApp);
StartUIForAppLaunch();
SimulateNetworkOffline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
// Simulate mounting of usb stick with v2 app on the stick.
bool update_success;
bool app_update_notified;
SimulateUpdateAppFromUsbStick(kFakeUsbMountPathUpdatePass,
&app_update_notified, &update_success);
EXPECT_TRUE(update_success);
EXPECT_TRUE(app_update_notified);
// The v2 kiosk app is loaded into external cache, but won't be installed
// until next time the device is started.
base::FilePath crx_path;
std::string cached_version;
EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(test_app_id(), &crx_path,
&cached_version));
EXPECT_EQ("2.0.0", cached_version);
EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
}
// Restart the device, verify the app has been updated to v2.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppNoNetwork) {
// Verify the kiosk app has been updated to v2.
set_test_app_id(kTestOfflineEnabledKioskApp);
StartUIForAppLaunch();
SimulateNetworkOffline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
}
// Usb stick is plugged in without a manifest file on it.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppNoManifest) {
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "1.0.0",
std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
// Simulate mounting of usb stick with v2 app on the stick.
bool update_success;
bool app_update_notified;
SimulateUpdateAppFromUsbStick(kFakeUsbMountPathNoManifest,
&app_update_notified, &update_success);
EXPECT_FALSE(update_success);
// Kiosk app is not updated.
base::FilePath crx_path;
std::string cached_version;
EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(test_app_id(), &crx_path,
&cached_version));
EXPECT_EQ("1.0.0", cached_version);
}
// Usb stick is plugged in with a bad manifest file on it.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppBadManifest) {
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "1.0.0",
std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
// Simulate mounting of usb stick with v2 app on the stick.
bool update_success;
bool app_update_notified;
SimulateUpdateAppFromUsbStick(kFakeUsbMountPathBadManifest,
&app_update_notified, &update_success);
EXPECT_FALSE(update_success);
// Kiosk app is not updated.
base::FilePath crx_path;
std::string cached_version;
EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(test_app_id(), &crx_path,
&cached_version));
EXPECT_EQ("1.0.0", cached_version);
}
// Usb stick is plugged in with a lower version of crx file specified in
// manifest.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppLowerAppVersion) {
// Precache v2 version of app.
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "2.0.0",
std::string(kTestOfflineEnabledKioskApp) + ".crx");
EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
// Simulate mounting of usb stick with v1 app on the stick.
bool update_success;
bool app_update_notified;
SimulateUpdateAppFromUsbStick(kFakeUsbMountPathLowerAppVersion,
&app_update_notified, &update_success);
EXPECT_FALSE(update_success);
// Kiosk app is NOT updated to the lower version.
base::FilePath crx_path;
std::string cached_version;
EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(test_app_id(), &crx_path,
&cached_version));
EXPECT_EQ("2.0.0", cached_version);
}
// Usb stick is plugged in with a v1 crx file, although the manifest says
// this is a v3 version.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppLowerCrxVersion) {
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "2.0.0",
std::string(kTestOfflineEnabledKioskApp) + ".crx");
EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
// Simulate mounting of usb stick with v1 crx file on the stick, although
// the manifest says it is v3 app.
bool update_success;
bool app_update_notified;
SimulateUpdateAppFromUsbStick(kFakeUsbMountPathLowerCrxVersion,
&app_update_notified, &update_success);
EXPECT_FALSE(update_success);
// Kiosk app is NOT updated to the lower version.
base::FilePath crx_path;
std::string cached_version;
EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(test_app_id(), &crx_path,
&cached_version));
EXPECT_EQ("2.0.0", cached_version);
}
// Usb stick is plugged in with a bad crx file.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppBadCrx) {
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "1.0.0",
std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
// Simulate mounting of usb stick with v1 crx file on the stick, although
// the manifest says it is v3 app.
bool update_success;
bool app_update_notified;
SimulateUpdateAppFromUsbStick(kFakeUsbMountPathBadCrx, &app_update_notified,
&update_success);
EXPECT_FALSE(update_success);
// Kiosk app is NOT updated.
base::FilePath crx_path;
std::string cached_version;
EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(test_app_id(), &crx_path,
&cached_version));
EXPECT_EQ("1.0.0", cached_version);
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_PermissionChange) {
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "2.0.0",
std::string(kTestOfflineEnabledKioskApp) + ".crx");
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PermissionChange) {
set_test_app_id(kTestOfflineEnabledKioskApp);
set_test_app_version("2.0.0");
set_test_crx_file(test_app_id() + "_v2_permission_change.crx");
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_PreserveLocalData) {
// Installs v1 app and writes some local data.
set_test_app_id(kTestLocalFsKioskApp);
set_test_app_version("1.0.0");
set_test_crx_file(test_app_id() + ".crx");
extensions::ResultCatcher catcher;
StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
WaitForAppLaunchWithOptions(true /* check_launch_data */,
false /* terminate_app */);
ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PreserveLocalData) {
// Update existing v1 app installed in PRE_PreserveLocalData to v2
// that reads and verifies the local data.
set_test_app_id(kTestLocalFsKioskApp);
set_test_app_version("2.0.0");
set_test_crx_file(test_app_id() + "_v2_read_and_verify_data.crx");
extensions::ResultCatcher catcher;
StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
WaitForAppLaunchWithOptions(true /* check_launch_data */,
false /* terminate_app */);
EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
}
// Tests the primary app install with required platform version. The test
// has three runs:
// 1. Install an app.
// 2. App update is delayed because the required platform version is not
// compliant.
// 3. Platform version changed and the new app is installed because it is
// compliant now.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
PRE_PRE_IncompliantPlatformDelayInstall) {
PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp, "1.0.0",
std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_IncompliantPlatformDelayInstall) {
SetPlatformVersion("1233.0.0");
set_test_app_id(kTestOfflineEnabledKioskApp);
set_test_app_version("2.0.0");
set_test_crx_file(test_app_id() + "_v2_required_platform_version_added.crx");
// Fake auto launch.
ReloadAutolaunchKioskApps();
KioskAppManager::Get()->SetAppWasAutoLaunchedWithZeroDelay(
kTestOfflineEnabledKioskApp);
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
EXPECT_TRUE(PrimaryAppUpdateIsPending());
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, IncompliantPlatformDelayInstall) {
SetPlatformVersion("1234.0.0");
set_test_app_id(kTestOfflineEnabledKioskApp);
set_test_app_version("2.0.0");
set_test_crx_file(test_app_id() + "_v2_required_platform_version_added.crx");
// Fake auto launch.
ReloadAutolaunchKioskApps();
KioskAppManager::Get()->SetAppWasAutoLaunchedWithZeroDelay(
kTestOfflineEnabledKioskApp);
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
EXPECT_FALSE(PrimaryAppUpdateIsPending());
}
// Tests that app is installed for the first time even on an incompliant
// platform.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, IncompliantPlatformFirstInstall) {
SetPlatformVersion("1233.0.0");
set_test_app_id(kTestOfflineEnabledKioskApp);
set_test_app_version("2.0.0");
set_test_crx_file(test_app_id() + "_v2_required_platform_version_added.crx");
// Fake auto launch.
ReloadAutolaunchKioskApps();
KioskAppManager::Get()->SetAppWasAutoLaunchedWithZeroDelay(
kTestOfflineEnabledKioskApp);
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchSuccess();
EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
EXPECT_FALSE(PrimaryAppUpdateIsPending());
}
/* ***** Test Kiosk multi-app feature ***** */
// Launch a primary kiosk app which has two secondary apps.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
LaunchTestKioskAppWithTwoSecondaryApps) {
LaunchTestKioskAppWithTwoSecondaryApps();
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_UpdateMultiAppKioskRemoveOneApp) {
LaunchTestKioskAppWithTwoSecondaryApps();
}
// Update the primary app to version 2 which removes one of the secondary app
// from its manifest.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UpdateMultiAppKioskRemoveOneApp) {
set_test_app_id(kTestPrimaryKioskApp);
fake_cws()->SetUpdateCrx(kTestPrimaryKioskApp,
std::string(kTestPrimaryKioskApp) + "-2.0.0.crx",
"2.0.0");
fake_cws()->SetNoUpdate(kTestSecondaryApp1);
fake_cws()->SetNoUpdate(kTestSecondaryApp2);
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchWithOptions(false, true);
// Verify the secondary app kTestSecondaryApp1 is removed.
EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
EXPECT_FALSE(IsAppInstalled(kTestSecondaryApp1, "1.0.0"));
EXPECT_TRUE(IsAppInstalled(kTestSecondaryApp2, "1.0.0"));
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_UpdateMultiAppKioskAddOneApp) {
LaunchTestKioskAppWithTwoSecondaryApps();
}
// Update the primary app to version 3 which adds a new secondary app in its
// manifest.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UpdateMultiAppKioskAddOneApp) {
set_test_app_id(kTestPrimaryKioskApp);
fake_cws()->SetUpdateCrx(kTestPrimaryKioskApp,
std::string(kTestPrimaryKioskApp) + "-3.0.0.crx",
"3.0.0");
fake_cws()->SetNoUpdate(kTestSecondaryApp1);
fake_cws()->SetNoUpdate(kTestSecondaryApp2);
fake_cws()->SetUpdateCrx(kTestSecondaryApp3,
std::string(kTestSecondaryApp3) + "-1.0.0.crx",
"1.0.0");
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchWithOptions(false, true);
// Verify the secondary app kTestSecondaryApp3 is installed.
EXPECT_EQ("3.0.0", GetInstalledAppVersion().GetString());
EXPECT_TRUE(IsAppInstalled(kTestSecondaryApp1, "1.0.0"));
EXPECT_TRUE(IsAppInstalled(kTestSecondaryApp2, "1.0.0"));
EXPECT_TRUE(IsAppInstalled(kTestSecondaryApp3, "1.0.0"));
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchKioskAppWithSecondaryExtension) {
LaunchTestKioskAppWithSeconadayExtension();
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
LaunchAppWithSharedModuleAndSecondaryApp) {
LaunchAppWithSharedModuleAndSecondaryApp();
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
PRE_UpdateAppWithSharedModuleRemoveAllSecondaryApps) {
LaunchAppWithSharedModuleAndSecondaryApp();
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
UpdateAppWithSharedModuleRemoveAllSecondaryApps) {
set_test_app_id(kTestSharedModulePrimaryApp);
fake_cws()->SetUpdateCrx(
kTestSharedModulePrimaryApp,
std::string(kTestSharedModulePrimaryApp) + "-2.0.0.crx", "2.0.0");
fake_cws()->SetNoUpdate(kTestSecondaryApp1);
fake_cws()->SetNoUpdate(kTestSharedModuleId);
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchWithOptions(false, true);
// Verify the secondary app is removed.
EXPECT_TRUE(IsAppInstalled(kTestSharedModuleId, "1.0.0"));
EXPECT_FALSE(IsAppInstalled(kTestSecondaryApp1, "1.0.0"));
}
// This simulates the stand-alone ARC kiosk app case. The primary app has a
// shared ARC runtime but no secondary apps.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchAppWithSharedModuleNoSecondary) {
LaunchAppWithSharedModule();
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchAppWithUpdatedModule) {
LaunchAppWithSharedModule();
// Verify the shared module is installed with version 1.0.0.
EXPECT_TRUE(IsAppInstalled(kTestSharedModuleId, "1.0.0"));
}
// This simulates the case the shared module is updated to a newer version.
// See crbug.com/555083.
IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchAppWithUpdatedModule) {
// No update for primary app, while the shared module is set up to a new
// version on cws.
set_test_app_id(kTestSharedModulePrimaryApp);
fake_cws()->SetNoUpdate(kTestSharedModulePrimaryApp);
fake_cws()->SetUpdateCrx(kTestSharedModuleId,
std::string(kTestSharedModuleId) + "-2.0.0.crx",
"2.0.0");
StartUIForAppLaunch();
SimulateNetworkOnline();
LaunchApp(test_app_id(), false);
WaitForAppLaunchWithOptions(false, true);
// Verify the shared module is updated to the new version after primary app
// is launched.
EXPECT_TRUE(IsAppInstalled(kTestSharedModuleId, "2.0.0"));
}
IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
LaunchAppWithSecondaryArcLikeAppAndExtension) {
TestAppInfo primary_app(
kTestSharedModulePrimaryApp, "3.0.0",
std::string(kTestSharedModulePrimaryApp) + "-3.0.0.crx",
extensions::Manifest::TYPE_PLATFORM_APP);
std::vector<TestAppInfo> secondary_apps;
// Setting up FakeCWS for shared module is the same for shared module as
// for kiosk secondary apps.
TestAppInfo shared_module(kTestSharedModuleId, "1.0.0",
std::string(kTestSharedModuleId) + "-1.0.0.crx",
extensions::Manifest::TYPE_SHARED_MODULE);
secondary_apps.push_back(shared_module);
// The secondary app has a shared module, which is similar to an ARC app.
TestAppInfo secondary_app(kTestSecondaryApp, "2.0.0",
std::string(kTestSecondaryApp) + "-2.0.0.crx",
extensions::Manifest::TYPE_PLATFORM_APP);
secondary_apps.push_back(secondary_app);
TestAppInfo secondary_ext(kTestSecondaryExt, "1.0.0",
std::string(kTestSecondaryExt) + "-1.0.0.crx",
extensions::Manifest::TYPE_EXTENSION);
secondary_apps.push_back(secondary_ext);
LaunchKioskWithSecondaryApps(primary_app, secondary_apps);
}
class KioskEnterpriseTest : public KioskTest {
protected:
KioskEnterpriseTest() { set_use_consumer_kiosk_mode(false); }
void SetUpInProcessBrowserTestFixture() override {
policy::DevicePolicyCrosTestHelper::MarkAsEnterpriseOwnedBy(
test_owner_account_id_.GetUserEmail());
settings_helper_.SetCurrentUserIsOwner(false);
KioskTest::SetUpInProcessBrowserTestFixture();
}
void SetUpOnMainThread() override {
KioskTest::SetUpOnMainThread();
// Configure OAuth authentication.
GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
// This token satisfies the userinfo.email request from
// DeviceOAuth2TokenService used in token validation.
FakeGaia::AccessTokenInfo userinfo_token_info;
userinfo_token_info.token = kTestUserinfoToken;
userinfo_token_info.scopes.insert(
"https://www.googleapis.com/auth/userinfo.email");
userinfo_token_info.audience = gaia_urls->oauth2_chrome_client_id();
userinfo_token_info.email = kTestEnterpriseServiceAccountId;
fake_gaia_->IssueOAuthToken(kTestRefreshToken, userinfo_token_info);
// The any-api access token for accessing the token minting endpoint.
FakeGaia::AccessTokenInfo login_token_info;
login_token_info.token = kTestLoginToken;
login_token_info.scopes.insert(GaiaConstants::kAnyApiOAuth2Scope);
login_token_info.audience = gaia_urls->oauth2_chrome_client_id();
fake_gaia_->IssueOAuthToken(kTestRefreshToken, login_token_info);
// This is the access token requested by the app via the identity API.
FakeGaia::AccessTokenInfo access_token_info;
access_token_info.token = kTestAccessToken;
access_token_info.scopes.insert(kTestAppScope);
access_token_info.audience = kTestClientId;
access_token_info.email = kTestEnterpriseServiceAccountId;
fake_gaia_->IssueOAuthToken(kTestLoginToken, access_token_info);
DeviceOAuth2TokenService* token_service =
DeviceOAuth2TokenServiceFactory::Get();
token_service->SetAndSaveRefreshToken(
kTestRefreshToken, DeviceOAuth2TokenService::StatusCallback());
base::RunLoop().RunUntilIdle();
}
void ConfigureKioskAppInPolicy(const std::string& account_id,
const std::string& app_id,
const std::string& update_url) {
settings_helper_.SetCurrentUserIsOwner(true);
std::vector<policy::DeviceLocalAccount> accounts;
accounts.push_back(
policy::DeviceLocalAccount(policy::DeviceLocalAccount::TYPE_KIOSK_APP,
account_id, app_id, update_url));
policy::SetDeviceLocalAccounts(owner_settings_service_.get(), accounts);
settings_helper_.SetString(kAccountsPrefDeviceLocalAccountAutoLoginId,
account_id);
settings_helper_.SetString(kServiceAccountIdentity,
kTestEnterpriseServiceAccountId);
settings_helper_.SetCurrentUserIsOwner(false);
}
private:
DISALLOW_COPY_AND_ASSIGN(KioskEnterpriseTest);
};
IN_PROC_BROWSER_TEST_F(KioskEnterpriseTest, EnterpriseKioskApp) {
// Prepare Fake CWS to serve app crx.
set_test_app_id(kTestEnterpriseKioskApp);
set_test_app_version("1.0.0");
set_test_crx_file(test_app_id() + ".crx");
SetupTestAppUpdateCheck();
// Configure kTestEnterpriseKioskApp in device policy.
ConfigureKioskAppInPolicy(kTestEnterpriseAccountId, kTestEnterpriseKioskApp,
"");
PrepareAppLaunch();
LaunchApp(kTestEnterpriseKioskApp, false);
KioskSessionInitializedWaiter().Wait();
// Check installer status.
EXPECT_EQ(chromeos::KioskAppLaunchError::NONE,
chromeos::KioskAppLaunchError::Get());
EXPECT_EQ(extensions::Manifest::EXTERNAL_POLICY, GetInstalledAppLocation());
// Wait for the window to appear.
extensions::AppWindow* window =
apps::AppWindowWaiter(extensions::AppWindowRegistry::Get(
ProfileManager::GetPrimaryUserProfile()),
kTestEnterpriseKioskApp)
.Wait();
ASSERT_TRUE(window);
content::WaitForLoadStop(window->web_contents());
// Check whether the app can retrieve an OAuth2 access token.
std::string result;
EXPECT_TRUE(content::ExecuteScriptAndExtractString(
window->web_contents(),
"chrome.identity.getAuthToken({ 'interactive': false }, function(token) {"
" window.domAutomationController.send(token);"
"});",
&result));
EXPECT_EQ(kTestAccessToken, result);
// Verify that the session is not considered to be logged in with a GAIA
// account.
Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
ASSERT_TRUE(app_profile);
EXPECT_FALSE(
SigninManagerFactory::GetForProfile(app_profile)->IsAuthenticated());
// Terminate the app.
window->GetBaseWindow()->Close();
content::RunAllPendingInMessageLoop();
}
IN_PROC_BROWSER_TEST_F(KioskEnterpriseTest, PrivateStore) {
set_test_app_id(kTestEnterpriseKioskApp);
const char kPrivateStoreUpdate[] = "/private_store_update";
net::EmbeddedTestServer private_server;
// |private_server| serves crx from test data dir.
base::FilePath test_data_dir;
PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
private_server.ServeFilesFromDirectory(test_data_dir);
ASSERT_TRUE(private_server.InitializeAndListen());
FakeCWS private_store;
private_store.InitAsPrivateStore(&private_server, kPrivateStoreUpdate);
private_store.SetUpdateCrx(kTestEnterpriseKioskApp,
std::string(kTestEnterpriseKioskApp) + ".crx",
"1.0.0");
private_server.StartAcceptingConnections();
// Configure kTestEnterpriseKioskApp in device policy.
ConfigureKioskAppInPolicy(kTestEnterpriseAccountId, kTestEnterpriseKioskApp,
private_server.GetURL(kPrivateStoreUpdate).spec());
// Meta should be able to be extracted from crx before launching.
KioskAppManager* manager = KioskAppManager::Get();
AppDataLoadWaiter waiter(manager, kTestEnterpriseKioskApp, std::string());
waiter.WaitForAppData();
PrepareAppLaunch();
LaunchApp(kTestEnterpriseKioskApp, false);
WaitForAppLaunchWithOptions(false /* check_launch_data */,
true /* terminate_app */);
// Private store should serve crx and CWS should not.
DCHECK_GT(private_store.GetUpdateCheckCountAndReset(), 0);
DCHECK_EQ(0, fake_cws()->GetUpdateCheckCountAndReset());
EXPECT_EQ(extensions::Manifest::EXTERNAL_POLICY, GetInstalledAppLocation());
}
// A custom SoundsManagerTestImpl implements Initialize and Play only.
// The difference with media::SoundsManagerImpl is AudioStreamHandler is
// only initialized upon Play is called, so the most recent AudioManager
// instance could be used, to make sure of using MockAudioManager to play
// bundled sounds.
// It's not a nested class under KioskVirtualKeyboardTest because forward
// declaration of a nested class is not possible.
// TODO(crbug.com/805319): remove this fake impl for test.
class KioskVirtualKeyboardTestSoundsManagerTestImpl
: public media::SoundsManager {
public:
KioskVirtualKeyboardTestSoundsManagerTestImpl() {}
bool Initialize(SoundKey key, const base::StringPiece& data) override {
sound_data_[key] = data.as_string();
return true;
}
bool Play(SoundKey key) override {
auto iter = sound_data_.find(key);
if (iter == sound_data_.end()) {
LOG(WARNING) << "Playing non-existent key = " << key;
return false;
}
auto handler = std::make_unique<media::AudioStreamHandler>(iter->second);
if (!handler->IsInitialized()) {
LOG(WARNING) << "Can't initialize AudioStreamHandler for key = " << key;
return false;
}
return handler->Play();
}
bool Stop(SoundKey key) override {
NOTIMPLEMENTED();
return false;
}
base::TimeDelta GetDuration(SoundKey key) override {
NOTIMPLEMENTED();
return base::TimeDelta();
}
private:
std::map<SoundKey, std::string> sound_data_;
DISALLOW_COPY_AND_ASSIGN(KioskVirtualKeyboardTestSoundsManagerTestImpl);
};
// Specialized test fixture for testing kiosk mode where virtual keyboard is
// enabled.
class KioskVirtualKeyboardTest : public KioskTest,
public audio::FakeSystemInfo {
public:
KioskVirtualKeyboardTest() {}
~KioskVirtualKeyboardTest() override = default;
protected:
// KioskVirtualKeyboardTest overrides:
void SetUp() override {
media::SoundsManager::InitializeForTesting(
new KioskVirtualKeyboardTestSoundsManagerTestImpl());
KioskTest::SetUp();
}
void SetUpCommandLine(base::CommandLine* command_line) override {
KioskTest::SetUpCommandLine(command_line);
command_line->AppendSwitchASCII(
extensions::switches::kWhitelistedExtensionID,
kTestVirtualKeyboardKioskApp);
command_line->AppendSwitch(keyboard::switches::kEnableVirtualKeyboard);
}
// audio::FakeSystemInfo override.
void HasInputDevices(HasInputDevicesCallback callback) override {
std::move(callback).Run(true);
}
// Use class variable for sane lifetime.
// TODO(https://crbug.com/812170): Remove it when media::AudioSystem becomes
// service-based.
std::unique_ptr<media::MockAudioManager> mock_audio_manager_;
private:
DISALLOW_COPY_AND_ASSIGN(KioskVirtualKeyboardTest);
};
// Verifies that chrome.virtualKeyboard.restrictFeatures and related private
// APIs work.
IN_PROC_BROWSER_TEST_F(KioskVirtualKeyboardTest, RestrictFeatures) {
// Mock existence of audio input.
// We cannot do this in SetUp because it's overriden in RunTestOnMainThread.
mock_audio_manager_ = std::make_unique<media::MockAudioManager>(
std::make_unique<media::TestAudioThread>());
mock_audio_manager_->SetHasInputDevices(true);
audio::FakeSystemInfo::OverrideGlobalBinderForAudioService(this);
set_test_app_id(kTestVirtualKeyboardKioskApp);
set_test_app_version("0.1");
set_test_crx_file(test_app_id() + ".crx");
extensions::ResultCatcher catcher;
StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
// Shutdown should be done in the same thread, thus not in the destructor.
mock_audio_manager_->Shutdown();
}
// Specialized test fixture for testing kiosk mode on the
// hidden WebUI initialization flow for slow hardware.
class KioskHiddenWebUITest : public KioskTest,
public ash::WallpaperControllerObserver {
public:
KioskHiddenWebUITest() : wallpaper_loaded_(false) {}
void SetUpOnMainThread() override {
LoginDisplayHostWebUI::DisableRestrictiveProxyCheckForTest();
KioskTest::SetUpOnMainThread();
ash::Shell::Get()->wallpaper_controller()->AddObserver(this);
}
void TearDownOnMainThread() override {
ash::Shell::Get()->wallpaper_controller()->RemoveObserver(this);
KioskTest::TearDownOnMainThread();
}
void WaitForWallpaper() {
if (!wallpaper_loaded_) {
runner_ = new content::MessageLoopRunner;
runner_->Run();
}
}
bool wallpaper_loaded() const { return wallpaper_loaded_; }
// ash::WallpaperControllerObserver overrides:
void OnWallpaperDataChanged() override {
wallpaper_loaded_ = true;
if (runner_.get())
runner_->Quit();
}
bool wallpaper_loaded_;
scoped_refptr<content::MessageLoopRunner> runner_;
private:
DISALLOW_COPY_AND_ASSIGN(KioskHiddenWebUITest);
};
IN_PROC_BROWSER_TEST_F(KioskHiddenWebUITest, AutolaunchWarning) {
// Add a device owner.
FakeChromeUserManager* user_manager = new FakeChromeUserManager();
user_manager->AddUser(test_owner_account_id_);
user_manager::ScopedUserManager enabler(base::WrapUnique(user_manager));
// Set kiosk app to autolaunch.
EnableConsumerKioskMode();
WizardController::SkipPostLoginScreensForTesting();
WizardController* wizard_controller = WizardController::default_controller();
CHECK(wizard_controller);
// Start login screen after configuring auto launch app since the warning
// is triggered when switching to login screen.
wizard_controller->AdvanceToScreen(OobeScreen::SCREEN_OOBE_NETWORK);
ReloadAutolaunchKioskApps();
wizard_controller->SkipToLoginForTesting(LoginScreenContext());
EXPECT_FALSE(KioskAppManager::Get()->GetAutoLaunchApp().empty());
EXPECT_FALSE(KioskAppManager::Get()->IsAutoLaunchEnabled());
// Wait for the auto launch warning come up.
content::WindowedNotificationObserver(
chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
content::NotificationService::AllSources())
.Wait();
// Wait for the wallpaper to load.
WaitForWallpaper();
EXPECT_TRUE(wallpaper_loaded());
}
} // namespace chromeos
| [
"sokolov.p@gmail.com"
] | sokolov.p@gmail.com |
e980945912dafeb369a51d0e503d0b191c80f16a | ec5e110d124344308a49f43894bda1b5cfdcf43d | /c++/array/array.h | 7df42e7e5bccc4a53fc1b6d6d5a214ad3fade076 | [
"Apache-2.0"
] | permissive | flange/basics | db3b6dd234ba17397e756cb3e02fa21973514280 | 2f0677e7b3fdf9bf924496a36340515419b5a376 | refs/heads/master | 2020-05-24T05:38:53.654054 | 2017-05-01T13:37:53 | 2017-05-01T13:37:53 | 84,827,153 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,600 | h | #ifndef __ARRAY_H__
#define __ARRAY_H__
#include <algorithm>
#include <array>
#include <memory>
#include <string>
#include <sstream>
#include <type_traits>
template <typename T, std::size_t N>
class Array {
private:
T m_data[N];
public:
class iterator {
friend class Array;
public:
iterator() : m_iter{nullptr} {}
iterator(const iterator& other) : m_iter{other.m_iter} {}
private:
iterator(T* t) : m_iter{t} {}
public:
T& operator=(const T& other) {
iterator tmp{other};
std::swap(m_iter, tmp.m_iter);
return *this;
}
T operator*() {
return *m_iter;
}
iterator& operator++() {
m_iter++;
return *this;
}
iterator operator++(int) {
iterator tmp{*this};
m_iter++;
return tmp;
}
bool operator==(const iterator& other) {
return (m_iter == other.m_iter);
}
bool operator!=(const iterator& other) {
return (m_iter != other.m_iter);
}
friend std::ostream& operator<<(std::ostream& os, const iterator& iter) noexcept {
return os << *(iter.m_iter);
}
private:
T* m_iter;
};
explicit Array() : m_data{} {}
iterator begin() {
iterator b{m_data};
return b;
}
iterator end() {
iterator e{m_data + N};
return e;
}
T& operator[](const std::size_t& index)
{
return m_data[index];
}
std::string toString()
{
std::stringstream res;
res << "[ ";
for (int i = 0; i < N; ++i)
res << m_data[i] << " ";
res << "]";
return res.str();
}
};
#endif // __ARRAY_H__
| [
"langefrq@informatik.hu-berlin.de"
] | langefrq@informatik.hu-berlin.de |
ef8b7e9a28933fa66580542202aa0cafce0dc33a | 16684eea5e4eff52f9b4be22e87a4aff1d418971 | /memory_leek_test.cpp | 376bba0ee30819325742e4d5bc74d66265bce66d | [] | no_license | jerk1991/MemoryChecker | 94ca585bd071f9032da43704d93bd5fb73b698e8 | 566cee910e61452c129da0e816306f8ea74dd6fc | refs/heads/master | 2021-01-13T01:41:32.140498 | 2015-09-04T06:56:14 | 2015-09-04T06:56:14 | 41,851,837 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 331 | cpp | #include <stdio.h>
#include <iostream>
#include "MemoryChecker.h"
#define new DEBUG_NEW
#define DEBUG_NEW new(__FILE__,__LINE__)
int main(int argc, char const *argv[])
{
int *plen = new int;
*plen = 0;
delete plen;
char* pstr = new char[35];
strcpy(pstr,"hello memory leek");
MemManager::GetInstance()->Dump();
return 0;
}
| [
"18fabragas@gmail.com"
] | 18fabragas@gmail.com |
34e563515789689b308a90bb87a82b44179294af | 72af4ae88195e8b3ea3aa763a87d30b6e0602161 | /src/qt/receivecoinsdialog.cpp | 1120aa52af796fab0e43c38c468078c2602ef270 | [
"MIT"
] | permissive | rivercoin/facilecoin-core | 2374f29acd6c692796a434b9a4b42a5355d58a82 | 0cb393087f2a8aa2122a6c9a2aca4d487a20c580 | refs/heads/master | 2021-01-09T06:35:11.827404 | 2016-05-25T19:32:03 | 2016-05-25T19:32:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,115 | cpp | // Copyright (c) 2011-2014 The FacileCoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "receivecoinsdialog.h"
#include "ui_receivecoinsdialog.h"
#include "addressbookpage.h"
#include "addresstablemodel.h"
#include "facilecoinunits.h"
#include "guiutil.h"
#include "optionsmodel.h"
#include "receiverequestdialog.h"
#include "recentrequeststablemodel.h"
#include "walletmodel.h"
#include <QAction>
#include <QCursor>
#include <QItemSelection>
#include <QMessageBox>
#include <QScrollBar>
#include <QTextDocument>
ReceiveCoinsDialog::ReceiveCoinsDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::ReceiveCoinsDialog),
model(0)
{
ui->setupUi(this);
#ifdef Q_OS_MAC // Icons on push buttons are very uncommon on Mac
ui->clearButton->setIcon(QIcon());
ui->receiveButton->setIcon(QIcon());
ui->showRequestButton->setIcon(QIcon());
ui->removeRequestButton->setIcon(QIcon());
#endif
// context menu actions
QAction *copyLabelAction = new QAction(tr("Copy label"), this);
QAction *copyMessageAction = new QAction(tr("Copy message"), this);
QAction *copyAmountAction = new QAction(tr("Copy amount"), this);
// context menu
contextMenu = new QMenu();
contextMenu->addAction(copyLabelAction);
contextMenu->addAction(copyMessageAction);
contextMenu->addAction(copyAmountAction);
// context menu signals
connect(ui->recentRequestsView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showMenu(QPoint)));
connect(copyLabelAction, SIGNAL(triggered()), this, SLOT(copyLabel()));
connect(copyMessageAction, SIGNAL(triggered()), this, SLOT(copyMessage()));
connect(copyAmountAction, SIGNAL(triggered()), this, SLOT(copyAmount()));
connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
}
void ReceiveCoinsDialog::setModel(WalletModel *model)
{
this->model = model;
if(model && model->getOptionsModel())
{
model->getRecentRequestsTableModel()->sort(RecentRequestsTableModel::Date, Qt::DescendingOrder);
connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
updateDisplayUnit();
QTableView* tableView = ui->recentRequestsView;
tableView->verticalHeader()->hide();
tableView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
tableView->setModel(model->getRecentRequestsTableModel());
tableView->setAlternatingRowColors(true);
tableView->setSelectionBehavior(QAbstractItemView::SelectRows);
tableView->setSelectionMode(QAbstractItemView::ContiguousSelection);
tableView->setColumnWidth(RecentRequestsTableModel::Date, DATE_COLUMN_WIDTH);
tableView->setColumnWidth(RecentRequestsTableModel::Label, LABEL_COLUMN_WIDTH);
connect(tableView->selectionModel(),
SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this,
SLOT(recentRequestsView_selectionChanged(QItemSelection, QItemSelection)));
// Last 2 columns are set by the columnResizingFixer, when the table geometry is ready.
columnResizingFixer = new GUIUtil::TableViewLastColumnResizingFixer(tableView, AMOUNT_MINIMUM_COLUMN_WIDTH, DATE_COLUMN_WIDTH);
}
}
ReceiveCoinsDialog::~ReceiveCoinsDialog()
{
delete ui;
}
void ReceiveCoinsDialog::clear()
{
ui->reqAmount->clear();
ui->reqLabel->setText("");
ui->reqMessage->setText("");
ui->reuseAddress->setChecked(false);
updateDisplayUnit();
}
void ReceiveCoinsDialog::reject()
{
clear();
}
void ReceiveCoinsDialog::accept()
{
clear();
}
void ReceiveCoinsDialog::updateDisplayUnit()
{
if(model && model->getOptionsModel())
{
ui->reqAmount->setDisplayUnit(model->getOptionsModel()->getDisplayUnit());
}
}
void ReceiveCoinsDialog::on_receiveButton_clicked()
{
if(!model || !model->getOptionsModel() || !model->getAddressTableModel() || !model->getRecentRequestsTableModel())
return;
QString address;
QString label = ui->reqLabel->text();
if(ui->reuseAddress->isChecked())
{
/* Choose existing receiving address */
AddressBookPage dlg(AddressBookPage::ForSelection, AddressBookPage::ReceivingTab, this);
dlg.setModel(model->getAddressTableModel());
if(dlg.exec())
{
address = dlg.getReturnValue();
if(label.isEmpty()) /* If no label provided, use the previously used label */
{
label = model->getAddressTableModel()->labelForAddress(address);
}
} else {
return;
}
} else {
/* Generate new receiving address */
address = model->getAddressTableModel()->addRow(AddressTableModel::Receive, label, "");
}
SendCoinsRecipient info(address, label,
ui->reqAmount->value(), ui->reqMessage->text());
ReceiveRequestDialog *dialog = new ReceiveRequestDialog(this);
dialog->setAttribute(Qt::WA_DeleteOnClose);
dialog->setModel(model->getOptionsModel());
dialog->setInfo(info);
dialog->show();
clear();
/* Store request for later reference */
model->getRecentRequestsTableModel()->addNewRequest(info);
}
void ReceiveCoinsDialog::on_recentRequestsView_doubleClicked(const QModelIndex &index)
{
const RecentRequestsTableModel *submodel = model->getRecentRequestsTableModel();
ReceiveRequestDialog *dialog = new ReceiveRequestDialog(this);
dialog->setModel(model->getOptionsModel());
dialog->setInfo(submodel->entry(index.row()).recipient);
dialog->setAttribute(Qt::WA_DeleteOnClose);
dialog->show();
}
void ReceiveCoinsDialog::recentRequestsView_selectionChanged(const QItemSelection &selected, const QItemSelection &deselected)
{
// Enable Show/Remove buttons only if anything is selected.
bool enable = !ui->recentRequestsView->selectionModel()->selectedRows().isEmpty();
ui->showRequestButton->setEnabled(enable);
ui->removeRequestButton->setEnabled(enable);
}
void ReceiveCoinsDialog::on_showRequestButton_clicked()
{
if(!model || !model->getRecentRequestsTableModel() || !ui->recentRequestsView->selectionModel())
return;
QModelIndexList selection = ui->recentRequestsView->selectionModel()->selectedRows();
foreach (QModelIndex index, selection)
{
on_recentRequestsView_doubleClicked(index);
}
}
void ReceiveCoinsDialog::on_removeRequestButton_clicked()
{
if(!model || !model->getRecentRequestsTableModel() || !ui->recentRequestsView->selectionModel())
return;
QModelIndexList selection = ui->recentRequestsView->selectionModel()->selectedRows();
if(selection.empty())
return;
// correct for selection mode ContiguousSelection
QModelIndex firstIndex = selection.at(0);
model->getRecentRequestsTableModel()->removeRows(firstIndex.row(), selection.length(), firstIndex.parent());
}
// We override the virtual resizeEvent of the QWidget to adjust tables column
// sizes as the tables width is proportional to the dialogs width.
void ReceiveCoinsDialog::resizeEvent(QResizeEvent *event)
{
QWidget::resizeEvent(event);
columnResizingFixer->stretchColumnWidth(RecentRequestsTableModel::Message);
}
void ReceiveCoinsDialog::keyPressEvent(QKeyEvent *event)
{
if (event->key() == Qt::Key_Return)
{
// press return -> submit form
if (ui->reqLabel->hasFocus() || ui->reqAmount->hasFocus() || ui->reqMessage->hasFocus())
{
event->ignore();
on_receiveButton_clicked();
return;
}
}
this->QDialog::keyPressEvent(event);
}
// copy column of selected row to clipboard
void ReceiveCoinsDialog::copyColumnToClipboard(int column)
{
if(!model || !model->getRecentRequestsTableModel() || !ui->recentRequestsView->selectionModel())
return;
QModelIndexList selection = ui->recentRequestsView->selectionModel()->selectedRows();
if(selection.empty())
return;
// correct for selection mode ContiguousSelection
QModelIndex firstIndex = selection.at(0);
GUIUtil::setClipboard(model->getRecentRequestsTableModel()->data(firstIndex.child(firstIndex.row(), column), Qt::EditRole).toString());
}
// context menu
void ReceiveCoinsDialog::showMenu(const QPoint &point)
{
if(!model || !model->getRecentRequestsTableModel() || !ui->recentRequestsView->selectionModel())
return;
QModelIndexList selection = ui->recentRequestsView->selectionModel()->selectedRows();
if(selection.empty())
return;
contextMenu->exec(QCursor::pos());
}
// context menu action: copy label
void ReceiveCoinsDialog::copyLabel()
{
copyColumnToClipboard(RecentRequestsTableModel::Label);
}
// context menu action: copy message
void ReceiveCoinsDialog::copyMessage()
{
copyColumnToClipboard(RecentRequestsTableModel::Message);
}
// context menu action: copy amount
void ReceiveCoinsDialog::copyAmount()
{
copyColumnToClipboard(RecentRequestsTableModel::Amount);
}
| [
"fcn@facilecoin.org"
] | fcn@facilecoin.org |
c7f848d0eb98db83b9d37861133dda37d86e8edb | 37e2a3e18dc74e26a46e6f62f65d9aa3cbf6a2bf | /include/caffe/layers/space_to_batch_nd_layer.hpp | 507b5869a164dd266424bf2f69697c3b4062b954 | [
"LicenseRef-scancode-generic-cla",
"BSD-2-Clause"
] | permissive | foss-for-synopsys-dwc-arc-processors/synopsys-caffe | bc5d91e81575460137fa22623ba01816413d3bf0 | 63123ca6c80b72365c87332bbb3de2995e063065 | refs/heads/main | 2023-09-02T10:25:17.991467 | 2023-08-02T11:01:05 | 2023-08-02T11:01:05 | 103,567,504 | 27 | 20 | NOASSERTION | 2023-08-02T10:44:05 | 2017-09-14T18:28:41 | C++ | UTF-8 | C++ | false | false | 1,412 | hpp | #ifndef CAFFE_SPACETOBATCHND_LAYER_HPP_
#define CAFFE_SPACETOBATCHND_LAYER_HPP_
#include <vector>
#include "caffe/blob.hpp"
#include "caffe/layer.hpp"
#include "caffe/proto/caffe.pb.h"
namespace caffe {
template <typename Dtype>
class SpaceToBatchNDLayer : public Layer<Dtype> {
public:
explicit SpaceToBatchNDLayer(const LayerParameter& param)
: Layer<Dtype>(param) {}
virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top);
virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top);
virtual inline const char* type() const { return "SpaceToBatchND"; }
virtual inline int ExactNumBottomBlobs() const { return 1; }
virtual inline int ExactNumTopBlobs() const { return 1; }
protected:
virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top);
/// @brief Not implemented (non-differentiable function)
virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
NOT_IMPLEMENTED;
}
private:
inline vector<int> indices(int offset, const vector<int> & shape) const;
inline int offset(const vector<int>& indices, const vector<int> & shape) const;
vector<int> block_shape_;
vector<int> paddings_;
};
} // namespace caffe
#endif // CAFFE_SPACETOBATCHND_LAYER_HPP_
| [
"haifenghan@qq.com"
] | haifenghan@qq.com |
4ed4b03bd598faeee4c2dfe7cd4f59cd74b3f8dc | 8ec422c8acf4b973307863ff81965ea61ff5b3f5 | /tools/MLBrowser/templeteprintingbrowser.h | ec0e388d78b695ab584d9078a022cd26b719ed0c | [] | no_license | raidenawkward/sharonstone | cee22ac30b4dd7cc274bd540bff99257677d3b4a | c893110830a5977a9ff6aaaa94399fb5873bfbf3 | refs/heads/master | 2021-01-22T01:54:54.515200 | 2013-06-30T10:08:58 | 2013-06-30T10:08:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,715 | h | #ifndef TEMPLETEPRINTINGBROWSER_H
#define TEMPLETEPRINTINGBROWSER_H
#include <QTextBrowser>
#include <QString>
#include <QPrinter>
#include "sscore/sstemplete.h"
#include "sscore/print/ssprintimpl.h"
#include "sscore/print/ssprintable.h"
#define TEMPLETEPRINTINGBROWSER_DEFAULT_TAG_PREFIX ("${")
#define TEMPLETEPRINTINGBROWSER_DEFAULT_TAG_SUFFIX ("}")
class TempletePrintingBrowser : public QTextBrowser, public SSTemplete, public SSPrintImpl, SSPrintable::SSPrintableCallback
{
Q_OBJECT
public:
explicit TempletePrintingBrowser(QWidget *parent = 0);
virtual ~TempletePrintingBrowser();
/*
* methods from SSTemplete
*/
virtual bool loadTemplete(string path);
virtual bool setTagValue(string tag, string value);
virtual bool appendTagValue(string tag, string value);
virtual bool isTagExist(string tag);
virtual string getNextTag();
virtual void clearAllTags();
virtual void setTagPrefix(string prefix);
virtual void setTagSuffix(string suffix);
/*
* methods from SSPrintImpl
*/
virtual bool preparePrint();
virtual bool printDoc();
virtual void fihishPrint();
virtual bool preparePreview();
virtual bool preview();
virtual void finishPreview();
virtual bool openOptionDialog();
virtual bool loadPrintable(SSPrintable* printable);
/*
* method from SSPrintableCallback
*/
virtual bool onPrintablePrint(int, string title, string value);
private slots:
void onPreviewRequest(QPrinter* printer);
private:
QString _templeteContent;
QString _tagPrefix;
QString _tagSuffix;
SSPrintable* _printable;
QPrinter *_printer;
};
#endif // TEMPLETEPRINTINGBROWSER_H
| [
"raiden.ht@gmail.com"
] | raiden.ht@gmail.com |
ade3cfb22434142281b885a77ae4a99faf94c2c4 | 3aa370d70852dd267347002efed3464764adc4c0 | /gdal_1/gdal_1/gdal_1.cpp | a511b19a034331183f57367070661fddd046c9ed | [] | no_license | softwareEngineering2018autumn/demo2 | 4c7a292e673172586cea1e2a5c1519d9d409f135 | 3029cf2ea7e56d2279cf9100ef641b394b8be770 | refs/heads/master | 2020-03-31T13:18:37.240733 | 2018-10-14T08:58:17 | 2018-10-14T08:58:17 | 152,250,267 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,831 | cpp | #include "stdafx.h"
#include<iostream>
#include "./gdal/gdal_priv.h"
#pragma comment(lib, "gdal_i.lib")
using namespace std;
int main()
{
GDALDataset* poSrcDs;
GDALDataset* poDstDs;
int imgXlen, imgYlen, bandNum;
char* srcPath = "pic.jpg";
char* dstPath = "ans.tif";
GByte* buffTmp;
GByte* copyTmp;
int StartX[2] = { 300 ,500};
int StartY[2] = { 300 ,500};
int tmpXlen[2] = { 100,50 };
int tmpYlen[2] = { 50,100 };
int value[2] = { 255, 0 };
/*注册驱动*/
GDALAllRegister();
poSrcDs = (GDALDataset*)GDALOpenShared(srcPath, GA_ReadOnly);
/*获取宽度，高度和波段数*/
imgXlen = poSrcDs->GetRasterXSize();
imgYlen = poSrcDs->GetRasterYSize();
bandNum = poSrcDs->GetRasterCount();
buffTmp = (GByte*)CPLMalloc(tmpXlen[0] *tmpYlen[0]*sizeof(GByte));
copyTmp = (GByte*)CPLMalloc(imgXlen*imgYlen * sizeof(GByte));
poDstDs = GetGDALDriverManager()->GetDriverByName("GTiff")->Create(dstPath, imgXlen, imgYlen, bandNum, GDT_Byte, NULL);
/*复制图像*/
for (int i = 0; i < bandNum; i++) {
poSrcDs->GetRasterBand(i + 1)->RasterIO(GF_Read, 0, 0, imgXlen, imgYlen, copyTmp, imgXlen, imgYlen, GDT_Byte, 0, 0);
poDstDs->GetRasterBand(i + 1)->RasterIO(GF_Write, 0, 0, imgXlen, imgYlen, copyTmp, imgXlen, imgYlen, GDT_Byte, 0, 0);
}
for (int i = 0; i < 2; i++) {
buffTmp = (GByte*)CPLMalloc(tmpXlen[i] * tmpYlen[i] * sizeof(GByte));
/*给缓冲区赋值*/
for (int j = 0; j < tmpYlen[i]; j++) {
for (int k = 0; k < tmpXlen[i]; k++) {
buffTmp[j*tmpXlen[i] + k] = (GByte)value[i];
}
}
/*替换*/
for (int j = 0; j < bandNum; j++) {
poDstDs->GetRasterBand(j + 1)->RasterIO(GF_Write, StartX[i], StartY[i], tmpXlen[i], tmpYlen[i], buffTmp, tmpXlen[i], tmpYlen[i], GDT_Byte, 0, 0);
}
CPLFree(buffTmp);
}
/*清除内存*/
GDALClose(poSrcDs);
GDALClose(poDstDs);
return 0;
}
| [
"1131487340@qq.com"
] | 1131487340@qq.com |
5495d58e1850dab41da7177b4e767d7fbaf8d1d1 | d562bdc35962d9a1116cc3ddc7aacafe0c96184c | /L6-ejercicio2.cpp | d54e61bb95881fff2921057496e00ff945b85ed4 | [] | no_license | agustindls/programacion-de-computadores | 4fb7d0827f4ed12c008998282ae0d999eb515e68 | 9969511c9e22f6683bf8352487a8f71746719b57 | refs/heads/main | 2023-03-11T01:03:16.893077 | 2021-03-02T02:52:59 | 2021-03-02T02:52:59 | 320,069,166 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 584 | cpp | #include <stdio.h>
int main() {
int numb1;
int numb2;
int numb3;
printf("ingrese primer numero\n");
scanf("%i" , &numb1);
printf("ingrese segundo numero\n");
scanf("%i" , &numb2);
printf("ingrese tercer numero\n");
scanf("%i" , &numb3);
if((numb1 > numb2) && (numb1 > numb3)) {
printf("el numero mayor es: %i\n", numb1);
} else if((numb2 > numb1) && (numb2 > numb3)) {
printf("el numero mayor es: %i\n", numb2);
} else if((numb3 > numb1) && (numb3 > numb2)) {
printf("el numero mayor es: %i\n", numb3);
} else {
printf("los tres numeros son iguales");
}
return 0;
} | [
"a.delasierra01@ufromail.cl"
] | a.delasierra01@ufromail.cl |
91de15bf885f76c8520b5f8434c54445b18fcd0a | 8a5ae995f94de81eec9658bffa4102f216df4481 | /cpp/oke/Linia.cpp | f540bdd71786f28a2d490c7bb1b4267b31fecdac | [] | no_license | maciej-brochocki/recruitment | 2d3d7701f1563c288a4d3939108fcadd6909c222 | 891aa24d496f6bb88cebe7915c56bd2614d738cc | refs/heads/master | 2021-01-17T07:23:05.507116 | 2017-12-20T20:47:13 | 2017-12-20T20:47:13 | 83,703,682 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 672 | cpp | // Linia.cpp: implementation of the Linia class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "oke.h"
#include "Linia.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Linia::Linia(int x1, int y1, int x2, int y2) : figura(x1, y1, x2, y2)
{
}
Linia::~Linia()
{
}
void Linia::rysuj(CWnd *okno)
{
CClientDC dc(okno);
dc.MoveTo(m_iX1,m_iY1);
dc.LineTo(m_iX2,m_iY2);
figura::rysuj(okno);
}
| [
"maciej.brochocki@bestideas.pl"
] | maciej.brochocki@bestideas.pl |
ae67f24efac20d201eef800f82256a0d510689bb | 2277375bd4a554d23da334dddd091a36138f5cae | /ThirdParty/Havok/Source/Common/Compat/Deprecated/Compat/manifest/hkHavok410b1Classes.cpp | d3b1c8b2a422b9431c102e85081a52ade71b76d9 | [] | no_license | kevinmore/Project-Nebula | 9a0553ccf8bdc1b4bb5e2588fc94516d9e3532bc | f6d284d4879ae1ea1bd30c5775ef8733cfafa71d | refs/heads/master | 2022-10-22T03:55:42.596618 | 2020-06-19T09:07:07 | 2020-06-19T09:07:07 | 25,372,691 | 6 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 354,003 | cpp | /*
*
* Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
* prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
* Product and Trade Secret source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2013 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
*
*/
#include <Common/Compat/hkCompat.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Compat/Deprecated/Compat/hkHavokAllClasses.h>
#if defined(HK_COMPILER_SNC)
# pragma diag_suppress=68 //integer sign change
#endif
namespace hkHavok410b1Classes
{
const char VersionString[] = "Havok-4.1.0-b1";
const int ClassVersion = 4;
extern hkClass hk2dAngConstraintAtomClass;
extern hkClass hkAabbClass;
extern hkClass hkAabbPhantomClass;
extern hkClass hkActionClass;
extern hkClass hkAngConstraintAtomClass;
extern hkClass hkAngFrictionConstraintAtomClass;
extern hkClass hkAngLimitConstraintAtomClass;
extern hkClass hkAngMotorConstraintAtomClass;
extern hkClass hkAngularDashpotActionClass;
extern hkClass hkAnimatedReferenceFrameClass;
extern hkClass hkAnimationBindingClass;
extern hkClass hkAnimationContainerClass;
extern hkClass hkAnnotationTrackAnnotationClass;
extern hkClass hkAnnotationTrackClass;
extern hkClass hkArrayActionClass;
extern hkClass hkBallAndSocketConstraintDataAtomsClass;
extern hkClass hkBallAndSocketConstraintDataClass;
extern hkClass hkBallSocketChainDataClass;
extern hkClass hkBallSocketChainDataConstraintInfoClass;
extern hkClass hkBallSocketConstraintAtomClass;
extern hkClass hkBaseObjectClass;
extern hkClass hkBinaryActionClass;
extern hkClass hkBitFieldClass;
extern hkClass hkBoneAttachmentClass;
extern hkClass hkBoneClass;
extern hkClass hkBoxMotionClass;
extern hkClass hkBoxShapeClass;
extern hkClass hkBreakableConstraintDataClass;
extern hkClass hkBridgeAtomsClass;
extern hkClass hkBridgeConstraintAtomClass;
extern hkClass hkBroadPhaseHandleClass;
extern hkClass hkBvShapeClass;
extern hkClass hkBvTreeShapeClass;
extern hkClass hkCachingShapePhantomClass;
extern hkClass hkCapsuleShapeClass;
extern hkClass hkCdBodyClass;
extern hkClass hkCharacterProxyCinfoClass;
extern hkClass hkClassClass;
extern hkClass hkClassEnumClass;
extern hkClass hkClassEnumItemClass;
extern hkClass hkClassMemberClass;
extern hkClass hkCollidableClass;
extern hkClass hkCollidableCollidableFilterClass;
extern hkClass hkCollisionFilterClass;
extern hkClass hkCollisionFilterListClass;
extern hkClass hkConeLimitConstraintAtomClass;
extern hkClass hkConstrainedSystemFilterClass;
extern hkClass hkConstraintAtomClass;
extern hkClass hkConstraintChainDataClass;
extern hkClass hkConstraintChainInstanceActionClass;
extern hkClass hkConstraintChainInstanceClass;
extern hkClass hkConstraintDataClass;
extern hkClass hkConstraintInfoClass;
extern hkClass hkConstraintInstanceClass;
extern hkClass hkConstraintMotorClass;
extern hkClass hkContactPointClass;
extern hkClass hkContactPointMaterialClass;
extern hkClass hkConvexListFilterClass;
extern hkClass hkConvexListShapeClass;
extern hkClass hkConvexPieceMeshShapeClass;
extern hkClass hkConvexPieceStreamDataClass;
extern hkClass hkConvexShapeClass;
extern hkClass hkConvexTransformShapeClass;
extern hkClass hkConvexTranslateShapeClass;
extern hkClass hkConvexVerticesShapeClass;
extern hkClass hkConvexVerticesShapeFourVectorsClass;
extern hkClass hkCylinderShapeClass;
extern hkClass hkDashpotActionClass;
extern hkClass hkDefaultAnimatedReferenceFrameClass;
extern hkClass hkDefaultConvexListFilterClass;
extern hkClass hkDeltaCompressedSkeletalAnimationClass;
extern hkClass hkDeltaCompressedSkeletalAnimationQuantizationFormatClass;
extern hkClass hkDisableEntityCollisionFilterClass;
extern hkClass hkDisplayBindingDataClass;
extern hkClass hkEntityClass;
extern hkClass hkEntityDeactivatorClass;
extern hkClass hkExtendedMeshShapeClass;
extern hkClass hkExtendedMeshShapeShapesSubpartClass;
extern hkClass hkExtendedMeshShapeSubpartClass;
extern hkClass hkExtendedMeshShapeTrianglesSubpartClass;
extern hkClass hkFakeRigidBodyDeactivatorClass;
extern hkClass hkFastMeshShapeClass;
extern hkClass hkFixedRigidMotionClass;
extern hkClass hkGenericConstraintDataClass;
extern hkClass hkGenericConstraintDataSchemeClass;
extern hkClass hkGroupCollisionFilterClass;
extern hkClass hkGroupFilterClass;
extern hkClass hkHeightFieldShapeClass;
extern hkClass hkHingeConstraintDataAtomsClass;
extern hkClass hkHingeConstraintDataClass;
extern hkClass hkHingeLimitsDataAtomsClass;
extern hkClass hkHingeLimitsDataClass;
extern hkClass hkInterleavedSkeletalAnimationClass;
extern hkClass hkKeyframedRigidMotionClass;
extern hkClass hkLimitedForceConstraintMotorClass;
extern hkClass hkLimitedHingeConstraintDataAtomsClass;
extern hkClass hkLimitedHingeConstraintDataClass;
extern hkClass hkLinConstraintAtomClass;
extern hkClass hkLinFrictionConstraintAtomClass;
extern hkClass hkLinLimitConstraintAtomClass;
extern hkClass hkLinMotorConstraintAtomClass;
extern hkClass hkLinSoftConstraintAtomClass;
extern hkClass hkLinearParametricCurveClass;
extern hkClass hkLinkedCollidableClass;
extern hkClass hkListShapeChildInfoClass;
extern hkClass hkListShapeClass;
extern hkClass hkMalleableConstraintDataClass;
extern hkClass hkMassChangerModifierConstraintAtomClass;
extern hkClass hkMaterialClass;
extern hkClass hkMaxSizeMotionClass;
extern hkClass hkMeshBindingClass;
extern hkClass hkMeshBindingMappingClass;
extern hkClass hkMeshMaterialClass;
extern hkClass hkMeshShapeClass;
extern hkClass hkMeshShapeSubpartClass;
extern hkClass hkModifierConstraintAtomClass;
extern hkClass hkMonitorStreamFrameInfoClass;
extern hkClass hkMonitorStreamStringMapClass;
extern hkClass hkMonitorStreamStringMapStringMapClass;
extern hkClass hkMoppBvTreeShapeClass;
extern hkClass hkMoppCodeClass;
extern hkClass hkMoppCodeCodeInfoClass;
extern hkClass hkMotionClass;
extern hkClass hkMotionStateClass;
extern hkClass hkMotorActionClass;
extern hkClass hkMouseSpringActionClass;
extern hkClass hkMovingSurfaceModifierConstraintAtomClass;
extern hkClass hkMultiRayShapeClass;
extern hkClass hkMultiRayShapeRayClass;
extern hkClass hkMultiSphereShapeClass;
extern hkClass hkMultiThreadLockClass;
extern hkClass hkNullCollisionFilterClass;
extern hkClass hkOverwritePivotConstraintAtomClass;
extern hkClass hkPackfileHeaderClass;
extern hkClass hkPackfileSectionHeaderClass;
extern hkClass hkPairwiseCollisionFilterClass;
extern hkClass hkPairwiseCollisionFilterCollisionPairClass;
extern hkClass hkParametricCurveClass;
extern hkClass hkPhantomCallbackShapeClass;
extern hkClass hkPhantomClass;
extern hkClass hkPhysicsDataClass;
extern hkClass hkPhysicsSystemClass;
extern hkClass hkPhysicsSystemDisplayBindingClass;
extern hkClass hkPlaneShapeClass;
extern hkClass hkPointToPathConstraintDataClass;
extern hkClass hkPointToPlaneConstraintDataAtomsClass;
extern hkClass hkPointToPlaneConstraintDataClass;
extern hkClass hkPositionConstraintMotorClass;
extern hkClass hkPoweredChainDataClass;
extern hkClass hkPoweredChainDataConstraintInfoClass;
extern hkClass hkPoweredChainMapperClass;
extern hkClass hkPoweredChainMapperLinkInfoClass;
extern hkClass hkPoweredChainMapperTargetClass;
extern hkClass hkPrismaticConstraintDataAtomsClass;
extern hkClass hkPrismaticConstraintDataClass;
extern hkClass hkPropertyClass;
extern hkClass hkPropertyValueClass;
extern hkClass hkPulleyConstraintAtomClass;
extern hkClass hkPulleyConstraintDataAtomsClass;
extern hkClass hkPulleyConstraintDataClass;
extern hkClass hkRagdollConstraintDataAtomsClass;
extern hkClass hkRagdollConstraintDataClass;
extern hkClass hkRagdollInstanceClass;
extern hkClass hkRagdollLimitsDataAtomsClass;
extern hkClass hkRagdollLimitsDataClass;
extern hkClass hkRagdollMotorConstraintAtomClass;
extern hkClass hkRayCollidableFilterClass;
extern hkClass hkRayShapeCollectionFilterClass;
extern hkClass hkReferencedObjectClass;
extern hkClass hkRejectRayChassisListenerClass;
extern hkClass hkReorientActionClass;
extern hkClass hkRigidBodyClass;
extern hkClass hkRigidBodyDeactivatorClass;
extern hkClass hkRigidBodyDisplayBindingClass;
extern hkClass hkRootLevelContainerClass;
extern hkClass hkRootLevelContainerNamedVariantClass;
extern hkClass hkSampledHeightFieldShapeClass;
extern hkClass hkSerializedDisplayMarkerClass;
extern hkClass hkSerializedDisplayMarkerListClass;
extern hkClass hkSerializedDisplayRbTransformsClass;
extern hkClass hkSerializedDisplayRbTransformsDisplayTransformPairClass;
extern hkClass hkSetLocalRotationsConstraintAtomClass;
extern hkClass hkSetLocalTransformsConstraintAtomClass;
extern hkClass hkSetLocalTranslationsConstraintAtomClass;
extern hkClass hkShapeClass;
extern hkClass hkShapeCollectionClass;
extern hkClass hkShapeCollectionFilterClass;
extern hkClass hkShapeContainerClass;
extern hkClass hkShapePhantomClass;
extern hkClass hkShapeRayCastInputClass;
extern hkClass hkSimpleMeshShapeClass;
extern hkClass hkSimpleMeshShapeTriangleClass;
extern hkClass hkSimpleShapePhantomClass;
extern hkClass hkSingleShapeContainerClass;
extern hkClass hkSkeletalAnimationClass;
extern hkClass hkSkeletonClass;
extern hkClass hkSkeletonMapperClass;
extern hkClass hkSkeletonMapperDataChainMappingClass;
extern hkClass hkSkeletonMapperDataClass;
extern hkClass hkSkeletonMapperDataSimpleMappingClass;
extern hkClass hkSoftContactModifierConstraintAtomClass;
extern hkClass hkSpatialRigidBodyDeactivatorClass;
extern hkClass hkSpatialRigidBodyDeactivatorSampleClass;
extern hkClass hkSphereClass;
extern hkClass hkSphereMotionClass;
extern hkClass hkSphereRepShapeClass;
extern hkClass hkSphereShapeClass;
extern hkClass hkSpringActionClass;
extern hkClass hkSpringDamperConstraintMotorClass;
extern hkClass hkStabilizedBoxMotionClass;
extern hkClass hkStabilizedSphereMotionClass;
extern hkClass hkStiffSpringChainDataClass;
extern hkClass hkStiffSpringChainDataConstraintInfoClass;
extern hkClass hkStiffSpringConstraintAtomClass;
extern hkClass hkStiffSpringConstraintDataAtomsClass;
extern hkClass hkStiffSpringConstraintDataClass;
extern hkClass hkStorageMeshShapeClass;
extern hkClass hkStorageMeshShapeSubpartStorageClass;
extern hkClass hkStorageSampledHeightFieldShapeClass;
extern hkClass hkSweptTransformClass;
extern hkClass hkThinBoxMotionClass;
extern hkClass hkTransformShapeClass;
extern hkClass hkTriSampledHeightFieldBvTreeShapeClass;
extern hkClass hkTriSampledHeightFieldCollectionClass;
extern hkClass hkTriangleShapeClass;
extern hkClass hkTwistLimitConstraintAtomClass;
extern hkClass hkTypedBroadPhaseHandleClass;
extern hkClass hkTyremarkPointClass;
extern hkClass hkTyremarksInfoClass;
extern hkClass hkTyremarksWheelClass;
extern hkClass hkUnaryActionClass;
extern hkClass hkVehicleAerodynamicsClass;
extern hkClass hkVehicleBrakeClass;
extern hkClass hkVehicleDataClass;
extern hkClass hkVehicleDataWheelComponentParamsClass;
extern hkClass hkVehicleDefaultAerodynamicsClass;
extern hkClass hkVehicleDefaultAnalogDriverInputClass;
extern hkClass hkVehicleDefaultBrakeClass;
extern hkClass hkVehicleDefaultBrakeWheelBrakingPropertiesClass;
extern hkClass hkVehicleDefaultEngineClass;
extern hkClass hkVehicleDefaultSteeringClass;
extern hkClass hkVehicleDefaultSuspensionClass;
extern hkClass hkVehicleDefaultSuspensionWheelSpringSuspensionParametersClass;
extern hkClass hkVehicleDefaultTransmissionClass;
extern hkClass hkVehicleDefaultVelocityDamperClass;
extern hkClass hkVehicleDriverInputAnalogStatusClass;
extern hkClass hkVehicleDriverInputClass;
extern hkClass hkVehicleDriverInputStatusClass;
extern hkClass hkVehicleEngineClass;
extern hkClass hkVehicleFrictionDescriptionAxisDescriptionClass;
extern hkClass hkVehicleFrictionDescriptionClass;
extern hkClass hkVehicleFrictionStatusAxisStatusClass;
extern hkClass hkVehicleFrictionStatusClass;
extern hkClass hkVehicleInstanceClass;
extern hkClass hkVehicleInstanceWheelInfoClass;
extern hkClass hkVehicleRaycastWheelCollideClass;
extern hkClass hkVehicleSteeringClass;
extern hkClass hkVehicleSuspensionClass;
extern hkClass hkVehicleSuspensionSuspensionWheelParametersClass;
extern hkClass hkVehicleTransmissionClass;
extern hkClass hkVehicleVelocityDamperClass;
extern hkClass hkVehicleWheelCollideClass;
extern hkClass hkVelocityConstraintMotorClass;
extern hkClass hkVersioningExceptionsArrayClass;
extern hkClass hkVersioningExceptionsArrayVersioningExceptionClass;
extern hkClass hkViscousSurfaceModifierConstraintAtomClass;
extern hkClass hkWaveletSkeletalAnimationClass;
extern hkClass hkWaveletSkeletalAnimationQuantizationFormatClass;
extern hkClass hkWheelConstraintDataAtomsClass;
extern hkClass hkWheelConstraintDataClass;
extern hkClass hkWorldCinfoClass;
extern hkClass hkWorldMemoryWatchDogClass;
extern hkClass hkWorldObjectClass;
extern hkClass hkbAdditiveBinaryBlenderGeneratorClass;
extern hkClass hkbAttributeModifierClass;
extern hkClass hkbBehaviorClass;
extern hkClass hkbBinaryBlenderGeneratorClass;
extern hkClass hkbBlenderGeneratorChildClass;
extern hkClass hkbBlenderGeneratorClass;
extern hkClass hkbBlendingTransitionEffectClass;
extern hkClass hkbCharacterBoneInfoClass;
extern hkClass hkbCharacterSetupClass;
extern hkClass hkbClipGeneratorClass;
extern hkClass hkbClipTriggerClass;
extern hkClass hkbControlLookAtModifierClass;
extern hkClass hkbEventClass;
extern hkClass hkbFootIkControlDataClass;
extern hkClass hkbFootIkControlsModifierClass;
extern hkClass hkbFootIkGainsClass;
extern hkClass hkbFootIkModifierClass;
extern hkClass hkbGeneratorClass;
extern hkClass hkbGetUpModifierClass;
extern hkClass hkbHandIkModifierClass;
extern hkClass hkbKeyframeDataClass;
extern hkClass hkbLookAtModifierClass;
extern hkClass hkbModifierClass;
extern hkClass hkbModifierGeneratorClass;
extern hkClass hkbModifierSequenceClass;
extern hkClass hkbNodeClass;
extern hkClass hkbPoseMatchingModifierClass;
extern hkClass hkbPoweredRagdollControlDataClass;
extern hkClass hkbPoweredRagdollControlsModifierClass;
extern hkClass hkbPoweredRagdollModifierClass;
extern hkClass hkbPredicateClass;
extern hkClass hkbRagdollDriverModifierClass;
extern hkClass hkbReachModifierClass;
extern hkClass hkbReferencePoseGeneratorClass;
extern hkClass hkbRigidBodyRagdollControlDataClass;
extern hkClass hkbRigidBodyRagdollControlsModifierClass;
extern hkClass hkbRigidBodyRagdollModifierClass;
extern hkClass hkbStateMachineClass;
extern hkClass hkbStateMachineIntervalClass;
extern hkClass hkbStateMachineStateInfoClass;
extern hkClass hkbStateMachineTransitionInfoClass;
extern hkClass hkbStringPredicateClass;
extern hkClass hkbTransitionEffectClass;
extern hkClass hkbVariableSetClass;
extern hkClass hkbVariableSetTargetClass;
extern hkClass hkbVariableSetVariableClass;
extern hkClass hkxAnimatedFloatClass;
extern hkClass hkxAnimatedMatrixClass;
extern hkClass hkxAnimatedQuaternionClass;
extern hkClass hkxAnimatedVectorClass;
extern hkClass hkxAttributeClass;
extern hkClass hkxAttributeGroupClass;
extern hkClass hkxCameraClass;
extern hkClass hkxEnvironmentClass;
extern hkClass hkxEnvironmentVariableClass;
extern hkClass hkxIndexBufferClass;
extern hkClass hkxLightClass;
extern hkClass hkxMaterialClass;
extern hkClass hkxMaterialEffectClass;
extern hkClass hkxMaterialTextureStageClass;
extern hkClass hkxMeshClass;
extern hkClass hkxMeshSectionClass;
extern hkClass hkxNodeAnnotationDataClass;
extern hkClass hkxNodeClass;
extern hkClass hkxSceneClass;
extern hkClass hkxSkinBindingClass;
extern hkClass hkxSparselyAnimatedBoolClass;
extern hkClass hkxSparselyAnimatedEnumClass;
extern hkClass hkxSparselyAnimatedIntClass;
extern hkClass hkxSparselyAnimatedStringClass;
extern hkClass hkxSparselyAnimatedStringStringTypeClass;
extern hkClass hkxTextureFileClass;
extern hkClass hkxTextureInplaceClass;
extern hkClass hkxVertexBufferClass;
extern hkClass hkxVertexFormatClass;
extern hkClass hkxVertexP4N4C1T2Class;
extern hkClass hkxVertexP4N4T4B4C1T2Class;
extern hkClass hkxVertexP4N4T4B4W4I4C1Q2Class;
extern hkClass hkxVertexP4N4T4B4W4I4Q4Class;
extern hkClass hkxVertexP4N4W4I4C1Q2Class;
static hkInternalClassMember hkAnimationContainerClass_Members[] =
{
{ "skeletons", &hkSkeletonClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "animations", &hkSkeletalAnimationClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "bindings", &hkAnimationBindingClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "attachments", &hkBoneAttachmentClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "skins", &hkMeshBindingClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkAnimationContainerClass(
"hkAnimationContainer",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkAnimationContainerClass_Members),
int(sizeof(hkAnimationContainerClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkAnimationBindingBlendHintEnumItems[] =
{
{0, "NORMAL"},
{1, "ADDITIVE"},
};
static const hkInternalClassEnum hkAnimationBindingEnums[] = {
{"BlendHint", hkAnimationBindingBlendHintEnumItems, 2, HK_NULL, 0 }
};
const hkClassEnum* hkAnimationBindingBlendHintEnum = reinterpret_cast<const hkClassEnum*>(&hkAnimationBindingEnums[0]);
static hkInternalClassMember hkAnimationBindingClass_Members[] =
{
{ "animation", &hkSkeletalAnimationClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "animationTrackToBoneIndices", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_INT16, 0, 0, 0, HK_NULL },
{ "blendHint", HK_NULL, hkAnimationBindingBlendHintEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL }
};
namespace
{
struct hkAnimationBinding_DefaultStruct
{
int s_defaultOffsets[3];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkInt8 /* enum BlendHint */ m_blendHint;
};
const hkAnimationBinding_DefaultStruct hkAnimationBinding_Default =
{
{-1,-1,HK_OFFSET_OF(hkAnimationBinding_DefaultStruct,m_blendHint)},
0
};
}
hkClass hkAnimationBindingClass(
"hkAnimationBinding",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkAnimationBindingEnums),
1,
reinterpret_cast<const hkClassMember*>(hkAnimationBindingClass_Members),
int(sizeof(hkAnimationBindingClass_Members)/sizeof(hkInternalClassMember)),
&hkAnimationBinding_Default
);
static hkInternalClassMember hkAnnotationTrack_AnnotationClass_Members[] =
{
{ "time", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "text", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkAnnotationTrackAnnotationClass(
"hkAnnotationTrackAnnotation",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkAnnotationTrack_AnnotationClass_Members),
int(sizeof(hkAnnotationTrack_AnnotationClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkAnnotationTrackClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "annotations", &hkAnnotationTrackAnnotationClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkAnnotationTrackClass(
"hkAnnotationTrack",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkAnnotationTrackClass_Members),
int(sizeof(hkAnnotationTrackClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
extern const hkClassEnum* hkSkeletalAnimationTypeEnum;
static const hkInternalClassEnumItem hkSkeletalAnimationTypeEnumItems[] =
{
{0, "HK_UNKNOWN_ANIMATION"},
{1, "HK_INTERLEAVED_ANIMATION"},
{2, "HK_DELTA_COMPRESSED_ANIMATION"},
{3, "HK_WAVELET_COMPRESSED_ANIMATION"},
};
static const hkInternalClassEnum hkSkeletalAnimationEnums[] = {
{"Type", hkSkeletalAnimationTypeEnumItems, 4, HK_NULL, 0 }
};
const hkClassEnum* hkSkeletalAnimationTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkSkeletalAnimationEnums[0]);
static hkInternalClassMember hkSkeletalAnimationClass_Members[] =
{
{ "type", HK_NULL, hkSkeletalAnimationTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_32, 0, HK_NULL },
{ "duration", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numberOfTracks", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "extractedMotion", &hkAnimatedReferenceFrameClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "annotationTracks", &hkAnnotationTrackClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkSkeletalAnimationClass(
"hkSkeletalAnimation",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkSkeletalAnimationEnums),
1,
reinterpret_cast<const hkClassMember*>(hkSkeletalAnimationClass_Members),
int(sizeof(hkSkeletalAnimationClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkDeltaCompressedSkeletalAnimation_QuantizationFormatClass_Members[] =
{
{ "maxBitWidth", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "preserved", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numD", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "offsetIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "scaleIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "bitWidthIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkDeltaCompressedSkeletalAnimationQuantizationFormatClass(
"hkDeltaCompressedSkeletalAnimationQuantizationFormat",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkDeltaCompressedSkeletalAnimation_QuantizationFormatClass_Members),
int(sizeof(hkDeltaCompressedSkeletalAnimation_QuantizationFormatClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkDeltaCompressedSkeletalAnimationClass_Members[] =
{
{ "numberOfPoses", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "blockSize", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "qFormat", &hkDeltaCompressedSkeletalAnimationQuantizationFormatClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "quantizedDataIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "quantizedDataSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "staticMaskIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "staticMaskSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "staticDOFsIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "staticDOFsSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "totalBlockSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lastBlockSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "dataBuffer", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_UINT8, 0, 0, 0, HK_NULL }
};
hkClass hkDeltaCompressedSkeletalAnimationClass(
"hkDeltaCompressedSkeletalAnimation",
&hkSkeletalAnimationClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkDeltaCompressedSkeletalAnimationClass_Members),
int(sizeof(hkDeltaCompressedSkeletalAnimationClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkInterleavedSkeletalAnimationClass_Members[] =
{
{ "transforms", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_QSTRANSFORM, 0, 0, 0, HK_NULL }
};
hkClass hkInterleavedSkeletalAnimationClass(
"hkInterleavedSkeletalAnimation",
&hkSkeletalAnimationClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkInterleavedSkeletalAnimationClass_Members),
int(sizeof(hkInterleavedSkeletalAnimationClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkWaveletSkeletalAnimation_QuantizationFormatClass_Members[] =
{
{ "maxBitWidth", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "preserved", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numD", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "offsetIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "scaleIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "bitWidthIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkWaveletSkeletalAnimationQuantizationFormatClass(
"hkWaveletSkeletalAnimationQuantizationFormat",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkWaveletSkeletalAnimation_QuantizationFormatClass_Members),
int(sizeof(hkWaveletSkeletalAnimation_QuantizationFormatClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkWaveletSkeletalAnimationClass_Members[] =
{
{ "numberOfPoses", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "blockSize", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "qFormat", &hkWaveletSkeletalAnimationQuantizationFormatClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "staticMaskIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "staticDOFsIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "blockIndexIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "blockIndexSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "quantizedDataIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "quantizedDataSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "dataBuffer", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_UINT8, 0, 0, 0, HK_NULL }
};
hkClass hkWaveletSkeletalAnimationClass(
"hkWaveletSkeletalAnimation",
&hkSkeletalAnimationClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkWaveletSkeletalAnimationClass_Members),
int(sizeof(hkWaveletSkeletalAnimationClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMeshBinding_MappingClass_Members[] =
{
{ "mapping", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_INT16, 0, 0, 0, HK_NULL }
};
hkClass hkMeshBindingMappingClass(
"hkMeshBindingMapping",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMeshBinding_MappingClass_Members),
int(sizeof(hkMeshBinding_MappingClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMeshBindingClass_Members[] =
{
{ "mesh", &hkxMeshClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "skeleton", &hkSkeletonClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "mappings", &hkMeshBindingMappingClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "inverseWorldBindPose", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_TRANSFORM, 0, 0, 0, HK_NULL }
};
hkClass hkMeshBindingClass(
"hkMeshBinding",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMeshBindingClass_Members),
int(sizeof(hkMeshBindingClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkSkeletonMapperConstraintSourceEnumItems[] =
{
{0, "NO_CONSTRAINTS"},
{1, "REFERENCE_POSE"},
{2, "CURRENT_POSE"},
};
static const hkInternalClassEnum hkSkeletonMapperEnums[] = {
{"ConstraintSource", hkSkeletonMapperConstraintSourceEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkSkeletonMapperConstraintSourceEnum = reinterpret_cast<const hkClassEnum*>(&hkSkeletonMapperEnums[0]);
static hkInternalClassMember hkSkeletonMapperClass_Members[] =
{
{ "mapping", &hkSkeletonMapperDataClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSkeletonMapperClass(
"hkSkeletonMapper",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkSkeletonMapperEnums),
1,
reinterpret_cast<const hkClassMember*>(hkSkeletonMapperClass_Members),
int(sizeof(hkSkeletonMapperClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSkeletonMapperData_SimpleMappingClass_Members[] =
{
{ "boneA", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "boneB", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "aFromBTransform", HK_NULL, HK_NULL, hkClassMember::TYPE_QSTRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSkeletonMapperDataSimpleMappingClass(
"hkSkeletonMapperDataSimpleMapping",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSkeletonMapperData_SimpleMappingClass_Members),
int(sizeof(hkSkeletonMapperData_SimpleMappingClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSkeletonMapperData_ChainMappingClass_Members[] =
{
{ "startBoneA", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "endBoneA", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "startBoneB", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "endBoneB", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "startAFromBTransform", HK_NULL, HK_NULL, hkClassMember::TYPE_QSTRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "endAFromBTransform", HK_NULL, HK_NULL, hkClassMember::TYPE_QSTRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSkeletonMapperDataChainMappingClass(
"hkSkeletonMapperDataChainMapping",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSkeletonMapperData_ChainMappingClass_Members),
int(sizeof(hkSkeletonMapperData_ChainMappingClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSkeletonMapperDataClass_Members[] =
{
{ "skeletonA", &hkSkeletonClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "skeletonB", &hkSkeletonClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "simpleMappings", &hkSkeletonMapperDataSimpleMappingClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "chainMappings", &hkSkeletonMapperDataChainMappingClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "unmappedBones", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_INT16, 0, 0, 0, HK_NULL },
{ "keepUnmappedLocal", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSkeletonMapperDataClass(
"hkSkeletonMapperData",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSkeletonMapperDataClass_Members),
int(sizeof(hkSkeletonMapperDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkAnimatedReferenceFrameClass(
"hkAnimatedReferenceFrame",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkDefaultAnimatedReferenceFrameClass_Members[] =
{
{ "up", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "forward", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "duration", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "referenceFrameSamples", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_VECTOR4, 0, 0, 0, HK_NULL }
};
hkClass hkDefaultAnimatedReferenceFrameClass(
"hkDefaultAnimatedReferenceFrame",
&hkAnimatedReferenceFrameClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkDefaultAnimatedReferenceFrameClass_Members),
int(sizeof(hkDefaultAnimatedReferenceFrameClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBoneClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lockTranslation", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBoneClass(
"hkBone",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBoneClass_Members),
int(sizeof(hkBoneClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBoneAttachmentClass_Members[] =
{
{ "boneFromAttachment", HK_NULL, HK_NULL, hkClassMember::TYPE_MATRIX4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "attachment", HK_NULL, HK_NULL, hkClassMember::TYPE_VARIANT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "boneIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBoneAttachmentClass(
"hkBoneAttachment",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBoneAttachmentClass_Members),
int(sizeof(hkBoneAttachmentClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSkeletonClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "parentIndices", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_INT16, 0, 0, 0, HK_NULL },
{ "bones", &hkBoneClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "referencePose", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_QSTRANSFORM, 0, 0, 0, HK_NULL }
};
hkClass hkSkeletonClass(
"hkSkeleton",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSkeletonClass_Members),
int(sizeof(hkSkeletonClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbBehaviorClass_Members[] =
{
{ "rootGenerator", &hkbGeneratorClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "variableSet", &hkbVariableSetClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "isClone", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "activeNodes", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "activeNodeToIndexMap", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkbBehaviorClass(
"hkbBehavior",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbBehaviorClass_Members),
int(sizeof(hkbBehaviorClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkbCharacterBoneInfoWhichLimbEnumItems[] =
{
{0, "FIRST_LIMB"},
{0, "LIMB_LEFT"},
{1, "LIMB_RIGHT"},
{2, "NUM_LIMBS"},
};
static const hkInternalClassEnum hkbCharacterBoneInfoEnums[] = {
{"WhichLimb", hkbCharacterBoneInfoWhichLimbEnumItems, 4, HK_NULL, 0 }
};
const hkClassEnum* hkbCharacterBoneInfoWhichLimbEnum = reinterpret_cast<const hkClassEnum*>(&hkbCharacterBoneInfoEnums[0]);
static hkInternalClassMember hkbCharacterBoneInfoClass_Members[] =
{
{ "clavicleIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "shoulderIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "elbowIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "wristIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "hipIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "kneeIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "ankleIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "pelvisIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "neckIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "headIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "spineIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_INT16, 0, 0, 0, HK_NULL }
};
hkClass hkbCharacterBoneInfoClass(
"hkbCharacterBoneInfo",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkbCharacterBoneInfoEnums),
1,
reinterpret_cast<const hkClassMember*>(hkbCharacterBoneInfoClass_Members),
int(sizeof(hkbCharacterBoneInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbCharacterSetupClass_Members[] =
{
{ "animationSkeleton", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "animationBoneInfo", &hkbCharacterBoneInfoClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "modelUpMS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "modelForwardMS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "modelRightMS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "attributeDefaults", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "ragdollSkeleton", &hkSkeletonClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "ragdollToAnimationSkeletonMapper", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "animationToRagdollSkeletonMapper", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "ragdollBoneInfo", &hkbCharacterBoneInfoClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "poseMatchingUtility", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbCharacterSetup_DefaultStruct
{
int s_defaultOffsets[11];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
const class hkSkeleton* m_animationSkeleton;
class hkSkeletonMapper* m_ragdollToAnimationSkeletonMapper;
class hkSkeletonMapper* m_animationToRagdollSkeletonMapper;
class hkPoseMatchingUtility* m_poseMatchingUtility;
};
const hkbCharacterSetup_DefaultStruct hkbCharacterSetup_Default =
{
{HK_OFFSET_OF(hkbCharacterSetup_DefaultStruct,m_animationSkeleton),-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkbCharacterSetup_DefaultStruct,m_ragdollToAnimationSkeletonMapper),HK_OFFSET_OF(hkbCharacterSetup_DefaultStruct,m_animationToRagdollSkeletonMapper),-1,HK_OFFSET_OF(hkbCharacterSetup_DefaultStruct,m_poseMatchingUtility)},
HK_NULL,HK_NULL,HK_NULL,HK_NULL
};
}
hkClass hkbCharacterSetupClass(
"hkbCharacterSetup",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbCharacterSetupClass_Members),
int(sizeof(hkbCharacterSetupClass_Members)/sizeof(hkInternalClassMember)),
&hkbCharacterSetup_Default
);
static const hkInternalClassEnumItem hkbEventSystemEventIdsEnumItems[] =
{
{-1, "NULL_EVENT"},
};
static const hkInternalClassEnum hkbEventEnums[] = {
{"SystemEventIds", hkbEventSystemEventIdsEnumItems, 1, HK_NULL, 0 }
};
const hkClassEnum* hkbEventSystemEventIdsEnum = reinterpret_cast<const hkClassEnum*>(&hkbEventEnums[0]);
static hkInternalClassMember hkbEventClass_Members[] =
{
{ "id", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "payload", HK_NULL, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbEventClass(
"hkbEvent",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkbEventEnums),
1,
reinterpret_cast<const hkClassMember*>(hkbEventClass_Members),
int(sizeof(hkbEventClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkbGeneratorClass(
"hkbGenerator",
&hkbNodeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkbBinaryBlenderGeneratorClass_Members[] =
{
{ "blendWeight", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "initialBlendWeight", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "sync", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "indexOfSyncMasterChild", HK_NULL, HK_NULL, hkClassMember::TYPE_INT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "generator", &hkbGeneratorClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 2, 0, 0, HK_NULL },
{ "childFrequencies", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "frequency", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbBinaryBlenderGenerator_DefaultStruct
{
int s_defaultOffsets[7];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_blendWeight;
hkReal m_initialBlendWeight;
_hkBool m_sync;
hkInt8 m_indexOfSyncMasterChild;
hkReal m_frequency;
};
const hkbBinaryBlenderGenerator_DefaultStruct hkbBinaryBlenderGenerator_Default =
{
{HK_OFFSET_OF(hkbBinaryBlenderGenerator_DefaultStruct,m_blendWeight),HK_OFFSET_OF(hkbBinaryBlenderGenerator_DefaultStruct,m_initialBlendWeight),HK_OFFSET_OF(hkbBinaryBlenderGenerator_DefaultStruct,m_sync),HK_OFFSET_OF(hkbBinaryBlenderGenerator_DefaultStruct,m_indexOfSyncMasterChild),-1,-1,HK_OFFSET_OF(hkbBinaryBlenderGenerator_DefaultStruct,m_frequency)},
0.0f,-1.0f,false,-1,0.0f
};
}
hkClass hkbBinaryBlenderGeneratorClass(
"hkbBinaryBlenderGenerator",
&hkbGeneratorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbBinaryBlenderGeneratorClass_Members),
int(sizeof(hkbBinaryBlenderGeneratorClass_Members)/sizeof(hkInternalClassMember)),
&hkbBinaryBlenderGenerator_Default
);
hkClass hkbAdditiveBinaryBlenderGeneratorClass(
"hkbAdditiveBinaryBlenderGenerator",
&hkbBinaryBlenderGeneratorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkbBlenderGeneratorChildClass_Members[] =
{
{ "generator", &hkbGeneratorClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "weight", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "boneWeights", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
hkClass hkbBlenderGeneratorChildClass(
"hkbBlenderGeneratorChild",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbBlenderGeneratorChildClass_Members),
int(sizeof(hkbBlenderGeneratorChildClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbBlenderGeneratorClass_Members[] =
{
{ "referencePoseWeightThreshold", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "indexOfSyncMasterChild", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "autoComputeSecondGeneratorWeight", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "sync", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "children", &hkbBlenderGeneratorChildClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "childFrequencies", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "frequency", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "numChildFrequencies", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_INT32, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbBlenderGenerator_DefaultStruct
{
int s_defaultOffsets[8];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_referencePoseWeightThreshold;
hkInt16 m_indexOfSyncMasterChild;
_hkBool m_autoComputeSecondGeneratorWeight;
_hkBool m_sync;
};
const hkbBlenderGenerator_DefaultStruct hkbBlenderGenerator_Default =
{
{HK_OFFSET_OF(hkbBlenderGenerator_DefaultStruct,m_referencePoseWeightThreshold),HK_OFFSET_OF(hkbBlenderGenerator_DefaultStruct,m_indexOfSyncMasterChild),HK_OFFSET_OF(hkbBlenderGenerator_DefaultStruct,m_autoComputeSecondGeneratorWeight),HK_OFFSET_OF(hkbBlenderGenerator_DefaultStruct,m_sync),-1,-1,-1,-1},
0.0f,-1,false,false
};
}
hkClass hkbBlenderGeneratorClass(
"hkbBlenderGenerator",
&hkbGeneratorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbBlenderGeneratorClass_Members),
int(sizeof(hkbBlenderGeneratorClass_Members)/sizeof(hkInternalClassMember)),
&hkbBlenderGenerator_Default
);
static hkInternalClassMember hkbClipTriggerClass_Members[] =
{
{ "localTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "event", &hkbEventClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "relativeToEndOfClip", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbClipTriggerClass(
"hkbClipTrigger",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbClipTriggerClass_Members),
int(sizeof(hkbClipTriggerClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkbClipGeneratorPlaybackModeEnumItems[] =
{
{0, "MODE_SINGLE_PLAY"},
{1, "MODE_LOOPING"},
{2, "MODE_USER_CONTROLLED"},
{3, "MODE_COUNT"},
};
static const hkInternalClassEnum hkbClipGeneratorEnums[] = {
{"PlaybackMode", hkbClipGeneratorPlaybackModeEnumItems, 4, HK_NULL, 0 }
};
const hkClassEnum* hkbClipGeneratorPlaybackModeEnum = reinterpret_cast<const hkClassEnum*>(&hkbClipGeneratorEnums[0]);
static hkInternalClassMember hkbClipGeneratorClass_Members[] =
{
{ "mode", HK_NULL, hkbClipGeneratorPlaybackModeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "cropStartAmountLocalTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "cropEndAmountLocalTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "startTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "playbackSpeed", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "enforcedDuration", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "continueMotionAtEnd", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "userControlledTimeFraction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "filename", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "triggers", &hkbClipTriggerClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "animationControl", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "atEnd", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "extractedMotion", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_QSTRANSFORM, 0, 0, 0, HK_NULL },
{ "ignoreStartTime", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "echos", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbClipGenerator_DefaultStruct
{
int s_defaultOffsets[15];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_enforcedDuration;
};
const hkbClipGenerator_DefaultStruct hkbClipGenerator_Default =
{
{-1,-1,-1,-1,-1,HK_OFFSET_OF(hkbClipGenerator_DefaultStruct,m_enforcedDuration),-1,-1,-1,-1,-1,-1,-1,-1,-1},
0.0f
};
}
hkClass hkbClipGeneratorClass(
"hkbClipGenerator",
&hkbGeneratorClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkbClipGeneratorEnums),
1,
reinterpret_cast<const hkClassMember*>(hkbClipGeneratorClass_Members),
int(sizeof(hkbClipGeneratorClass_Members)/sizeof(hkInternalClassMember)),
&hkbClipGenerator_Default
);
static hkInternalClassMember hkbModifierGeneratorClass_Members[] =
{
{ "modifier", &hkbModifierClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "generator", &hkbGeneratorClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkbModifierGeneratorClass(
"hkbModifierGenerator",
&hkbGeneratorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbModifierGeneratorClass_Members),
int(sizeof(hkbModifierGeneratorClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbReferencePoseGeneratorClass_Members[] =
{
{ "skeleton", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkbReferencePoseGeneratorClass(
"hkbReferencePoseGenerator",
&hkbGeneratorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbReferencePoseGeneratorClass_Members),
int(sizeof(hkbReferencePoseGeneratorClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkbModifierClass(
"hkbModifier",
&hkbNodeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkbAttributeModifierClass_Members[] =
{
{ "attributes", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "attributeIndices", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_INT32, 0, 0, 0, HK_NULL }
};
hkClass hkbAttributeModifierClass(
"hkbAttributeModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbAttributeModifierClass_Members),
int(sizeof(hkbAttributeModifierClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbFootIkGainsClass_Members[] =
{
{ "onOffGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "ascendingGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "standAscendingGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "descendingGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbFootIkGainsClass(
"hkbFootIkGains",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbFootIkGainsClass_Members),
int(sizeof(hkbFootIkGainsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbFootIkControlDataClass_Members[] =
{
{ "isFootIkEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "gains", &hkbFootIkGainsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbFootIkControlDataClass(
"hkbFootIkControlData",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbFootIkControlDataClass_Members),
int(sizeof(hkbFootIkControlDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbFootIkModifierClass_Members[] =
{
{ "gains", &hkbFootIkGainsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxFootHeightMS", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "minFootHeightMS", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "isStanding", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "isFootOnAir", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "originalFootMsIsSet", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "originalFootMS", HK_NULL, HK_NULL, hkClassMember::TYPE_QSTRANSFORM, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "originalGroundHeightMS", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "kneeAxisLS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "useTrackData", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "isSetUp", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "raycastInterface", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "leftFootIkSolver", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "rightFootIkSolver", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "error", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "prevIsFootIkEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbFootIkModifier_DefaultStruct
{
int s_defaultOffsets[16];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
_hkBool m_isSetUp;
class hkRaycastInterface* m_raycastInterface;
hkReal m_prevIsFootIkEnabled;
};
const hkbFootIkModifier_DefaultStruct hkbFootIkModifier_Default =
{
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkbFootIkModifier_DefaultStruct,m_isSetUp),HK_OFFSET_OF(hkbFootIkModifier_DefaultStruct,m_raycastInterface),-1,-1,-1,HK_OFFSET_OF(hkbFootIkModifier_DefaultStruct,m_prevIsFootIkEnabled)},
false,HK_NULL,0.0f
};
}
hkClass hkbFootIkModifierClass(
"hkbFootIkModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbFootIkModifierClass_Members),
int(sizeof(hkbFootIkModifierClass_Members)/sizeof(hkInternalClassMember)),
&hkbFootIkModifier_Default
);
static hkInternalClassMember hkbFootIkControlsModifierClass_Members[] =
{
{ "controlData", &hkbFootIkControlDataClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbFootIkControlsModifierClass(
"hkbFootIkControlsModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbFootIkControlsModifierClass_Members),
int(sizeof(hkbFootIkControlsModifierClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbGetUpModifierClass_Members[] =
{
{ "duration", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "initNextModify", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "timeSinceBegin", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "timeStep", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbGetUpModifier_DefaultStruct
{
int s_defaultOffsets[4];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_duration;
_hkBool m_initNextModify;
hkReal m_timeSinceBegin;
hkReal m_timeStep;
};
const hkbGetUpModifier_DefaultStruct hkbGetUpModifier_Default =
{
{HK_OFFSET_OF(hkbGetUpModifier_DefaultStruct,m_duration),HK_OFFSET_OF(hkbGetUpModifier_DefaultStruct,m_initNextModify),HK_OFFSET_OF(hkbGetUpModifier_DefaultStruct,m_timeSinceBegin),HK_OFFSET_OF(hkbGetUpModifier_DefaultStruct,m_timeStep)},
1.0f,false,0.0f,0.0f
};
}
hkClass hkbGetUpModifierClass(
"hkbGetUpModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbGetUpModifierClass_Members),
int(sizeof(hkbGetUpModifierClass_Members)/sizeof(hkInternalClassMember)),
&hkbGetUpModifier_Default
);
static hkInternalClassMember hkbHandIkModifierClass_Members[] =
{
{ "previousReachPointWS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "previousNormalWS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "radarLocationRS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "elbowAxisLS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "backHandNormalInHandSpace", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "reachReferenceBoneIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "reachStopped", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "hasBeenSetup", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "pad", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL }
};
hkClass hkbHandIkModifierClass(
"hkbHandIkModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbHandIkModifierClass_Members),
int(sizeof(hkbHandIkModifierClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbLookAtModifierClass_Members[] =
{
{ "targetGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lookAtGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lookAtLimit", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "targetWS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lookUp", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lookUpAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "headForwardHS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "headRightHS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "isOn", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lookAtLastTargetWS", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lookAtWeight", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbLookAtModifierClass(
"hkbLookAtModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbLookAtModifierClass_Members),
int(sizeof(hkbLookAtModifierClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbControlLookAtModifierClass_Members[] =
{
{ "lookAtMod", &hkbLookAtModifierClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "isOn", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbControlLookAtModifierClass(
"hkbControlLookAtModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbControlLookAtModifierClass_Members),
int(sizeof(hkbControlLookAtModifierClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkbPoseMatchingModifierModePMAMEnumItems[] =
{
{0, "MODE_MATCH"},
{1, "MODE_PLAY"},
};
static const hkInternalClassEnum hkbPoseMatchingModifierEnums[] = {
{"ModePMAM", hkbPoseMatchingModifierModePMAMEnumItems, 2, HK_NULL, 0 }
};
const hkClassEnum* hkbPoseMatchingModifierModePMAMEnum = reinterpret_cast<const hkClassEnum*>(&hkbPoseMatchingModifierEnums[0]);
static hkInternalClassMember hkbPoseMatchingModifierClass_Members[] =
{
{ "hysteresis", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "blendSpeed", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "playbackSpeed", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "doneEventLeadTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "mode", HK_NULL, hkbPoseMatchingModifierModePMAMEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "annotationName", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "donePlayingEvent", &hkbEventClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "animations", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL },
{ "animatedSkeleton", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "matchingPoseControl", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "matchingPose", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "currentMatch", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "bestMatch", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "timeSinceBetterMatch", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "getUpControl", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "error", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "motionTimestep", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbPoseMatchingModifier_DefaultStruct
{
int s_defaultOffsets[17];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
class hkAnimatedSkeleton* m_animatedSkeleton;
class PoseMatchingAnimationMixerControl* m_matchingPoseControl;
class PoseMatchingAnimationMixerSkeletalAnimation* m_matchingPose;
class hkDefaultAnimationControl* m_getUpControl;
hkReal m_error;
hkReal m_motionTimestep;
};
const hkbPoseMatchingModifier_DefaultStruct hkbPoseMatchingModifier_Default =
{
{-1,-1,-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkbPoseMatchingModifier_DefaultStruct,m_animatedSkeleton),HK_OFFSET_OF(hkbPoseMatchingModifier_DefaultStruct,m_matchingPoseControl),HK_OFFSET_OF(hkbPoseMatchingModifier_DefaultStruct,m_matchingPose),-1,-1,-1,HK_OFFSET_OF(hkbPoseMatchingModifier_DefaultStruct,m_getUpControl),HK_OFFSET_OF(hkbPoseMatchingModifier_DefaultStruct,m_error),HK_OFFSET_OF(hkbPoseMatchingModifier_DefaultStruct,m_motionTimestep)},
HK_NULL,HK_NULL,HK_NULL,HK_NULL,3.40282e+38f,0.0f
};
}
hkClass hkbPoseMatchingModifierClass(
"hkbPoseMatchingModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkbPoseMatchingModifierEnums),
1,
reinterpret_cast<const hkClassMember*>(hkbPoseMatchingModifierClass_Members),
int(sizeof(hkbPoseMatchingModifierClass_Members)/sizeof(hkInternalClassMember)),
&hkbPoseMatchingModifier_Default
);
static hkInternalClassMember hkbKeyframeDataClass_Members[] =
{
{ "isDataInitialized", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "keyframeData", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_QSTRANSFORM, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbKeyframeData_DefaultStruct
{
int s_defaultOffsets[2];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
_hkBool m_isDataInitialized;
};
const hkbKeyframeData_DefaultStruct hkbKeyframeData_Default =
{
{HK_OFFSET_OF(hkbKeyframeData_DefaultStruct,m_isDataInitialized),-1},
false
};
}
hkClass hkbKeyframeDataClass(
"hkbKeyframeData",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbKeyframeDataClass_Members),
int(sizeof(hkbKeyframeDataClass_Members)/sizeof(hkInternalClassMember)),
&hkbKeyframeData_Default
);
static hkInternalClassMember hkbPoweredRagdollControlDataClass_Members[] =
{
{ "weight", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxForce", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tau", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "damping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "proportionalRecoveryVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "constantRecoveryVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbPoweredRagdollControlDataClass(
"hkbPoweredRagdollControlData",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbPoweredRagdollControlDataClass_Members),
int(sizeof(hkbPoweredRagdollControlDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkbPoweredRagdollModifierComputeWorldFromModelModeEnumItems[] =
{
{0, "WORLD_FROM_MODEL_MODE_COMPUTE"},
{1, "WORLD_FROM_MODEL_MODE_USE_INOUT"},
{2, "WORLD_FROM_MODEL_MODE_USE_INPUT"},
};
static const hkInternalClassEnum hkbPoweredRagdollModifierEnums[] = {
{"ComputeWorldFromModelMode", hkbPoweredRagdollModifierComputeWorldFromModelModeEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkbPoweredRagdollModifierComputeWorldFromModelModeEnum = reinterpret_cast<const hkClassEnum*>(&hkbPoweredRagdollModifierEnums[0]);
static hkInternalClassMember hkbPoweredRagdollModifierClass_Members[] =
{
{ "floorRaycastLayer", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "controls", &hkbPoweredRagdollControlDataClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "blendInTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "computeWorldFromModelMode", HK_NULL, hkbPoweredRagdollModifierComputeWorldFromModelModeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "fixConstraintsTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "useLocking", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "timeActive", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "timeSinceLastModify", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "keyframedBones", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_INT32, 0, 0, 0, HK_NULL },
{ "keyframeData", &hkbKeyframeDataClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "boneWeights", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbPoweredRagdollModifier_DefaultStruct
{
int s_defaultOffsets[11];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_timeActive;
hkReal m_timeSinceLastModify;
};
const hkbPoweredRagdollModifier_DefaultStruct hkbPoweredRagdollModifier_Default =
{
{-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkbPoweredRagdollModifier_DefaultStruct,m_timeActive),HK_OFFSET_OF(hkbPoweredRagdollModifier_DefaultStruct,m_timeSinceLastModify),-1,-1,-1},
0,0.0f
};
}
hkClass hkbPoweredRagdollModifierClass(
"hkbPoweredRagdollModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkbPoweredRagdollModifierEnums),
1,
reinterpret_cast<const hkClassMember*>(hkbPoweredRagdollModifierClass_Members),
int(sizeof(hkbPoweredRagdollModifierClass_Members)/sizeof(hkInternalClassMember)),
&hkbPoweredRagdollModifier_Default
);
static hkInternalClassMember hkbPoweredRagdollControlsModifierClass_Members[] =
{
{ "controlData", &hkbPoweredRagdollControlDataClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "boneWeights", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
hkClass hkbPoweredRagdollControlsModifierClass(
"hkbPoweredRagdollControlsModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbPoweredRagdollControlsModifierClass_Members),
int(sizeof(hkbPoweredRagdollControlsModifierClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbRagdollDriverModifierClass_Members[] =
{
{ "addRagdollToWorld", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "removeRagdollFromWorld", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "poweredRagdollModifier", &hkbPoweredRagdollModifierClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "rigidBodyRagdollModifier", &hkbRigidBodyRagdollModifierClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "activeModifier", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "doSetup", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbRagdollDriverModifier_DefaultStruct
{
int s_defaultOffsets[6];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
_hkBool m_addRagdollToWorld;
_hkBool m_removeRagdollFromWorld;
class hkbModifier* m_activeModifier;
_hkBool m_doSetup;
};
const hkbRagdollDriverModifier_DefaultStruct hkbRagdollDriverModifier_Default =
{
{HK_OFFSET_OF(hkbRagdollDriverModifier_DefaultStruct,m_addRagdollToWorld),HK_OFFSET_OF(hkbRagdollDriverModifier_DefaultStruct,m_removeRagdollFromWorld),-1,-1,HK_OFFSET_OF(hkbRagdollDriverModifier_DefaultStruct,m_activeModifier),HK_OFFSET_OF(hkbRagdollDriverModifier_DefaultStruct,m_doSetup)},
false,false,HK_NULL,true
};
}
hkClass hkbRagdollDriverModifierClass(
"hkbRagdollDriverModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbRagdollDriverModifierClass_Members),
int(sizeof(hkbRagdollDriverModifierClass_Members)/sizeof(hkInternalClassMember)),
&hkbRagdollDriverModifier_Default
);
static hkInternalClassMember hkbRigidBodyRagdollControlDataClass_Members[] =
{
{ "weight", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "hierarchyGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "velocityDamping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "accelerationGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "velocityGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "positionGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "positionMaxLinearVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "positionMaxAngularVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "snapGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "snapMaxLinearVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "snapMaxAngularVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "snapMaxLinearDistance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "snapMaxAngularDistance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "durationToBlend", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbRigidBodyRagdollControlDataClass(
"hkbRigidBodyRagdollControlData",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbRigidBodyRagdollControlDataClass_Members),
int(sizeof(hkbRigidBodyRagdollControlDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbRigidBodyRagdollModifierClass_Members[] =
{
{ "controlDataPalette", &hkbRigidBodyRagdollControlDataClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "bodyIndexToPaletteIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_INT32, 0, 0, 0, HK_NULL },
{ "fixLegs", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lowerBodyBones", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_INT16, 0, 0, 0, HK_NULL },
{ "rigidBodyController", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "doSetupNextEvaluate", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "timeSinceLastModify", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "timeSinceBegin", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbRigidBodyRagdollModifier_DefaultStruct
{
int s_defaultOffsets[8];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
class hkRagdollRigidBodyController* m_rigidBodyController;
_hkBool m_doSetupNextEvaluate;
hkReal m_timeSinceLastModify;
hkReal m_timeSinceBegin;
};
const hkbRigidBodyRagdollModifier_DefaultStruct hkbRigidBodyRagdollModifier_Default =
{
{-1,-1,-1,-1,HK_OFFSET_OF(hkbRigidBodyRagdollModifier_DefaultStruct,m_rigidBodyController),HK_OFFSET_OF(hkbRigidBodyRagdollModifier_DefaultStruct,m_doSetupNextEvaluate),HK_OFFSET_OF(hkbRigidBodyRagdollModifier_DefaultStruct,m_timeSinceLastModify),HK_OFFSET_OF(hkbRigidBodyRagdollModifier_DefaultStruct,m_timeSinceBegin)},
HK_NULL,true,0.0f,0.0f
};
}
hkClass hkbRigidBodyRagdollModifierClass(
"hkbRigidBodyRagdollModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbRigidBodyRagdollModifierClass_Members),
int(sizeof(hkbRigidBodyRagdollModifierClass_Members)/sizeof(hkInternalClassMember)),
&hkbRigidBodyRagdollModifier_Default
);
static hkInternalClassMember hkbRigidBodyRagdollControlsModifierClass_Members[] =
{
{ "controlData", &hkbRigidBodyRagdollControlDataClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbRigidBodyRagdollControlsModifierClass(
"hkbRigidBodyRagdollControlsModifier",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbRigidBodyRagdollControlsModifierClass_Members),
int(sizeof(hkbRigidBodyRagdollControlsModifierClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbReachModifierClass_Members[] =
{
{ "raycastInterface", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "reachWeight", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "moveGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "leaveGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "reachGain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "raycastLayer", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbReachModifierClass(
"hkbReachModifier",
&hkbHandIkModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbReachModifierClass_Members),
int(sizeof(hkbReachModifierClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbModifierSequenceClass_Members[] =
{
{ "modifiers", &hkbModifierClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkbModifierSequenceClass(
"hkbModifierSequence",
&hkbModifierClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbModifierSequenceClass_Members),
int(sizeof(hkbModifierSequenceClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkbNodeGetChildrenFlagBitsEnumItems[] =
{
{0x1, "FLAG_ACTIVE_ONLY"},
{0x2, "FLAG_GENERATORS_ONLY"},
{0x4, "FLAG_COMPUTE_CHILD_SPEEDS"},
};
static const hkInternalClassEnum hkbNodeEnums[] = {
{"GetChildrenFlagBits", hkbNodeGetChildrenFlagBitsEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkbNodeGetChildrenFlagBitsEnum = reinterpret_cast<const hkClassEnum*>(&hkbNodeEnums[0]);
static hkInternalClassMember hkbNodeClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbNodeClass(
"hkbNode",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkbNodeEnums),
1,
reinterpret_cast<const hkClassMember*>(hkbNodeClass_Members),
int(sizeof(hkbNodeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkbPredicateClass(
"hkbPredicate",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkbStringPredicateClass_Members[] =
{
{ "predicateString", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbStringPredicateClass(
"hkbStringPredicate",
&hkbPredicateClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbStringPredicateClass_Members),
int(sizeof(hkbStringPredicateClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbStateMachine_IntervalClass_Members[] =
{
{ "startEventId", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "endEventId", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "startTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "endTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkbStateMachineIntervalClass(
"hkbStateMachineInterval",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbStateMachine_IntervalClass_Members),
int(sizeof(hkbStateMachine_IntervalClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkbStateMachineTransitionInfoTransitionInfoFlagBitsEnumItems[] =
{
{0x1, "FLAG_USE_EVENT_INTERVAL"},
{0x2, "FLAG_USE_BEGIN_INTERVAL"},
{0x4, "FLAG_UNINTERRUPTIBLE_WHILE_PLAYING"},
{0x8, "FLAG_UNINTERRUPTIBLE_WHILE_DELAYED"},
{0x10, "FLAG_DELAY_STATE_CHANGE"},
{0x20, "FLAG_DISABLED"},
{0x40, "FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE"},
{0x80, "FLAG_DISALLOW_RANDOM_TRANSITION"},
{0x100, "FLAG_DISABLE_PREDICATE"},
{0x4000, "FLAG_INTERNAL_IN_EVENT_INTERVAL"},
{0x8000, "FLAG_INTERNAL_IN_BEGIN_INTERVAL"},
};
static const hkInternalClassEnum hkbStateMachineTransitionInfoEnums[] = {
{"TransitionInfoFlagBits", hkbStateMachineTransitionInfoTransitionInfoFlagBitsEnumItems, 11, HK_NULL, 0 }
};
const hkClassEnum* hkbStateMachineTransitionInfoTransitionInfoFlagBitsEnum = reinterpret_cast<const hkClassEnum*>(&hkbStateMachineTransitionInfoEnums[0]);
static hkInternalClassMember hkbStateMachine_TransitionInfoClass_Members[] =
{
{ "eventId", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "toState", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "transition", &hkbTransitionEffectClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "predicate", &hkbPredicateClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "eventInterval", &hkbStateMachineIntervalClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "beginInterval", &hkbStateMachineIntervalClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "priority", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "flags", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbStateMachineTransitionInfo_DefaultStruct
{
int s_defaultOffsets[8];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkInt16 m_priority;
hkUint16 m_flags;
};
const hkbStateMachineTransitionInfo_DefaultStruct hkbStateMachineTransitionInfo_Default =
{
{-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkbStateMachineTransitionInfo_DefaultStruct,m_priority),HK_OFFSET_OF(hkbStateMachineTransitionInfo_DefaultStruct,m_flags)},
0,0
};
}
hkClass hkbStateMachineTransitionInfoClass(
"hkbStateMachineTransitionInfo",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkbStateMachineTransitionInfoEnums),
1,
reinterpret_cast<const hkClassMember*>(hkbStateMachine_TransitionInfoClass_Members),
int(sizeof(hkbStateMachine_TransitionInfoClass_Members)/sizeof(hkInternalClassMember)),
&hkbStateMachineTransitionInfo_Default
);
static hkInternalClassMember hkbStateMachine_StateInfoClass_Members[] =
{
{ "generator", &hkbGeneratorClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "transitions", &hkbStateMachineTransitionInfoClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkbStateMachineStateInfoClass(
"hkbStateMachineStateInfo",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbStateMachine_StateInfoClass_Members),
int(sizeof(hkbStateMachine_StateInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbStateMachineClass_Members[] =
{
{ "eventToSendWhenStateOrTransitionChanges", &hkbEventClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "startState", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "returnToPreviousStateEventId", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "randomTransitionEventId", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "enterStartStateOnBegin", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "randomStartState", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxSimultaneousTransitions", HK_NULL, HK_NULL, hkClassMember::TYPE_INT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "states", &hkbStateMachineStateInfoClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "globalTransitions", &hkbStateMachineTransitionInfoClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "activeTransitions", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL },
{ "state", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_INT32, 0, 0, 0, HK_NULL },
{ "delayedTransition", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "isActive", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "stateOrTransitionChanged", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "timeInState", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "previousState", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_INT32, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbStateMachine_DefaultStruct
{
int s_defaultOffsets[16];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkInt32 m_returnToPreviousStateEventId;
hkInt32 m_randomTransitionEventId;
_hkBool m_randomStartState;
hkInt8 m_maxSimultaneousTransitions;
hkReal m_timeInState;
};
const hkbStateMachine_DefaultStruct hkbStateMachine_Default =
{
{-1,-1,HK_OFFSET_OF(hkbStateMachine_DefaultStruct,m_returnToPreviousStateEventId),HK_OFFSET_OF(hkbStateMachine_DefaultStruct,m_randomTransitionEventId),-1,HK_OFFSET_OF(hkbStateMachine_DefaultStruct,m_randomStartState),HK_OFFSET_OF(hkbStateMachine_DefaultStruct,m_maxSimultaneousTransitions),-1,-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkbStateMachine_DefaultStruct,m_timeInState),-1},
-1,-1,false,32,0.0f
};
}
hkClass hkbStateMachineClass(
"hkbStateMachine",
&hkbGeneratorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbStateMachineClass_Members),
int(sizeof(hkbStateMachineClass_Members)/sizeof(hkInternalClassMember)),
&hkbStateMachine_Default
);
hkClass hkbTransitionEffectClass(
"hkbTransitionEffect",
&hkbGeneratorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static const hkInternalClassEnumItem hkbBlendingTransitionEffectFlagsBTBitsEnumItems[] =
{
{0x0, "FLAG_NONE"},
{0x1, "FLAG_IGNORE_FROM_WORLD_FROM_MODEL"},
{0x2, "FLAG_SYNC"},
};
static const hkInternalClassEnumItem hkbBlendingTransitionEffectEndModeBTEnumItems[] =
{
{0, "END_MODE_NONE"},
{1, "END_MODE_TRANSITION_UNTIL_END_OF_FROM_GENERATOR"},
{2, "END_MODE_CAP_DURATION_AT_END_OF_FROM_GENERATOR"},
};
static const hkInternalClassEnum hkbBlendingTransitionEffectEnums[] = {
{"FlagsBTBits", hkbBlendingTransitionEffectFlagsBTBitsEnumItems, 3, HK_NULL, 0 },
{"EndModeBT", hkbBlendingTransitionEffectEndModeBTEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkbBlendingTransitionEffectFlagsBTBitsEnum = reinterpret_cast<const hkClassEnum*>(&hkbBlendingTransitionEffectEnums[0]);
const hkClassEnum* hkbBlendingTransitionEffectEndModeBTEnum = reinterpret_cast<const hkClassEnum*>(&hkbBlendingTransitionEffectEnums[1]);
static hkInternalClassMember hkbBlendingTransitionEffectClass_Members[] =
{
{ "duration", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "toGeneratorStartTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "flags", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "endMode", HK_NULL, hkbBlendingTransitionEffectEndModeBTEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "fromGenerator", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "toGenerator", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "childFrequencies", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "timeRemaining", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "localTime", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "frequency", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "timeInTransition", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "isClone", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbBlendingTransitionEffect_DefaultStruct
{
int s_defaultOffsets[12];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_toGeneratorStartTime;
hkInt8 /* enum EndModeBT */ m_endMode;
};
const hkbBlendingTransitionEffect_DefaultStruct hkbBlendingTransitionEffect_Default =
{
{-1,HK_OFFSET_OF(hkbBlendingTransitionEffect_DefaultStruct,m_toGeneratorStartTime),-1,HK_OFFSET_OF(hkbBlendingTransitionEffect_DefaultStruct,m_endMode),-1,-1,-1,-1,-1,-1,-1,-1},
0.0f,0
};
}
hkClass hkbBlendingTransitionEffectClass(
"hkbBlendingTransitionEffect",
&hkbTransitionEffectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkbBlendingTransitionEffectEnums),
2,
reinterpret_cast<const hkClassMember*>(hkbBlendingTransitionEffectClass_Members),
int(sizeof(hkbBlendingTransitionEffectClass_Members)/sizeof(hkInternalClassMember)),
&hkbBlendingTransitionEffect_Default
);
static const hkInternalClassEnumItem hkbVariableSetVariableTypeEnumItems[] =
{
{-1, "VARIABLE_TYPE_INVALID"},
{0, "VARIABLE_TYPE_REAL"},
{1, "VARIABLE_TYPE_BOOL"},
};
static const hkInternalClassEnum hkbVariableSetEnums[] = {
{"VariableType", hkbVariableSetVariableTypeEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkbVariableSetVariableTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkbVariableSetEnums[0]);
static hkInternalClassMember hkbVariableSet_TargetClass_Members[] =
{
{ "object", &hkReferencedObjectClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "memberName", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "arrayIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "memberIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_INT32, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkbVariableSetTarget_DefaultStruct
{
int s_defaultOffsets[4];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
int m_memberIndex;
};
const hkbVariableSetTarget_DefaultStruct hkbVariableSetTarget_Default =
{
{-1,-1,-1,HK_OFFSET_OF(hkbVariableSetTarget_DefaultStruct,m_memberIndex)},
-1
};
}
hkClass hkbVariableSetTargetClass(
"hkbVariableSetTarget",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbVariableSet_TargetClass_Members),
int(sizeof(hkbVariableSet_TargetClass_Members)/sizeof(hkInternalClassMember)),
&hkbVariableSetTarget_Default
);
static hkInternalClassMember hkbVariableSet_VariableClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "targets", &hkbVariableSetTargetClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkbVariableSetVariableClass(
"hkbVariableSetVariable",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkbVariableSet_VariableClass_Members),
int(sizeof(hkbVariableSet_VariableClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkbVariableSetClass_Members[] =
{
{ "variables", &hkbVariableSetVariableClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkbVariableSetClass(
"hkbVariableSet",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkbVariableSetEnums),
1,
reinterpret_cast<const hkClassMember*>(hkbVariableSetClass_Members),
int(sizeof(hkbVariableSetClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkBaseObjectClass(
"hkBaseObject",
HK_NULL,
0,
HK_NULL,
1,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkReferencedObjectClass_Members[] =
{
{ "memSizeAndFlags", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_UINT16, 0, 0, 0, HK_NULL },
{ "referenceCount", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_INT16, 0, 0, 0, HK_NULL }
};
hkClass hkReferencedObjectClass(
"hkReferencedObject",
&hkBaseObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkReferencedObjectClass_Members),
int(sizeof(hkReferencedObjectClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkClassSignatureFlagsEnumItems[] =
{
{1, "SIGNATURE_LOCAL"},
};
static const hkInternalClassEnum hkClassEnums[] = {
{"SignatureFlags", hkClassSignatureFlagsEnumItems, 1, HK_NULL, 0 }
};
const hkClassEnum* hkClassSignatureFlagsEnum = reinterpret_cast<const hkClassEnum*>(&hkClassEnums[0]);
static hkInternalClassMember hkClassClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "parent", &hkClassClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "objectSize", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numImplementedInterfaces", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "declaredEnums", &hkClassEnumClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "declaredMembers", &hkClassMemberClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "defaults", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkClassClass(
"hkClass",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkClassEnums),
1,
reinterpret_cast<const hkClassMember*>(hkClassClass_Members),
int(sizeof(hkClassClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkClassEnum_ItemClass_Members[] =
{
{ "value", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkClassEnumItemClass(
"hkClassEnumItem",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkClassEnum_ItemClass_Members),
int(sizeof(hkClassEnum_ItemClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkClassEnumClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "items", &hkClassEnumItemClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkClassEnumClass(
"hkClassEnum",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkClassEnumClass_Members),
int(sizeof(hkClassEnumClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkClassMemberTypeEnumItems[] =
{
{0, "TYPE_VOID"},
{1, "TYPE_BOOL"},
{2, "TYPE_CHAR"},
{3, "TYPE_INT8"},
{4, "TYPE_UINT8"},
{5, "TYPE_INT16"},
{6, "TYPE_UINT16"},
{7, "TYPE_INT32"},
{8, "TYPE_UINT32"},
{9, "TYPE_INT64"},
{10, "TYPE_UINT64"},
{11, "TYPE_REAL"},
{12, "TYPE_VECTOR4"},
{13, "TYPE_QUATERNION"},
{14, "TYPE_MATRIX3"},
{15, "TYPE_ROTATION"},
{16, "TYPE_QSTRANSFORM"},
{17, "TYPE_MATRIX4"},
{18, "TYPE_TRANSFORM"},
{19, "TYPE_ZERO"},
{20, "TYPE_POINTER"},
{21, "TYPE_FUNCTIONPOINTER"},
{22, "TYPE_ARRAY"},
{23, "TYPE_INPLACEARRAY"},
{24, "TYPE_ENUM"},
{25, "TYPE_STRUCT"},
{26, "TYPE_SIMPLEARRAY"},
{27, "TYPE_HOMOGENEOUSARRAY"},
{28, "TYPE_VARIANT"},
{29, "TYPE_CSTRING"},
{30, "TYPE_ULONG"},
{31, "TYPE_MAX"},
};
static const hkInternalClassEnumItem hkClassMemberFlagsEnumItems[] =
{
{1, "POINTER_OPTIONAL"},
{2, "POINTER_VOIDSTAR"},
{8, "ENUM_8"},
{16, "ENUM_16"},
{32, "ENUM_32"},
{64, "ARRAY_RAWDATA"},
};
static const hkInternalClassEnumItem hkClassMemberRangeEnumItems[] =
{
{0, "INVALID"},
{1, "DEFAULT"},
{2, "ABS_MIN"},
{4, "ABS_MAX"},
{8, "SOFT_MIN"},
{16, "SOFT_MAX"},
{32, "RANGE_MAX"},
};
static const hkInternalClassEnum hkClassMemberEnums[] = {
{"Type", hkClassMemberTypeEnumItems, 32, HK_NULL, 0 },
{"Flags", hkClassMemberFlagsEnumItems, 6, HK_NULL, 0 },
{"Range", hkClassMemberRangeEnumItems, 7, HK_NULL, 0 }
};
const hkClassEnum* hkClassMemberTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkClassMemberEnums[0]);
const hkClassEnum* hkClassMemberFlagsEnum = reinterpret_cast<const hkClassEnum*>(&hkClassMemberEnums[1]);
const hkClassEnum* hkClassMemberRangeEnum = reinterpret_cast<const hkClassEnum*>(&hkClassMemberEnums[2]);
static hkInternalClassMember hkClassMemberClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "class", &hkClassClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "enum", &hkClassEnumClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "type", HK_NULL, hkClassMemberTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "subtype", HK_NULL, hkClassMemberTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "cArraySize", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "flags", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "offset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkClassMemberClass(
"hkClassMember",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkClassMemberEnums),
3,
reinterpret_cast<const hkClassMember*>(hkClassMemberClass_Members),
int(sizeof(hkClassMemberClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBitFieldClass_Members[] =
{
{ "words", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_UINT32, 0, 0, 0, HK_NULL }
};
hkClass hkBitFieldClass(
"hkBitField",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBitFieldClass_Members),
int(sizeof(hkBitFieldClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMonitorStreamStringMap_StringMapClass_Members[] =
{
{ "id", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT64, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "string", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMonitorStreamStringMapStringMapClass(
"hkMonitorStreamStringMapStringMap",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMonitorStreamStringMap_StringMapClass_Members),
int(sizeof(hkMonitorStreamStringMap_StringMapClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMonitorStreamStringMapClass_Members[] =
{
{ "map", &hkMonitorStreamStringMapStringMapClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkMonitorStreamStringMapClass(
"hkMonitorStreamStringMap",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMonitorStreamStringMapClass_Members),
int(sizeof(hkMonitorStreamStringMapClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkMonitorStreamFrameInfoAbsoluteTimeCounterEnumItems[] =
{
{0, "ABSOLUTE_TIME_TIMER_0"},
{1, "ABSOLUTE_TIME_TIMER_1"},
{0xffffffff, "ABSOLUTE_TIME_NOT_TIMED"},
};
static const hkInternalClassEnum hkMonitorStreamFrameInfoEnums[] = {
{"AbsoluteTimeCounter", hkMonitorStreamFrameInfoAbsoluteTimeCounterEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkMonitorStreamFrameInfoAbsoluteTimeCounterEnum = reinterpret_cast<const hkClassEnum*>(&hkMonitorStreamFrameInfoEnums[0]);
static hkInternalClassMember hkMonitorStreamFrameInfoClass_Members[] =
{
{ "heading", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "indexOfTimer0", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "indexOfTimer1", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "absoluteTimeCounter", HK_NULL, hkMonitorStreamFrameInfoAbsoluteTimeCounterEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_32, 0, HK_NULL },
{ "timerFactor0", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "timerFactor1", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMonitorStreamFrameInfoClass(
"hkMonitorStreamFrameInfo",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkMonitorStreamFrameInfoEnums),
1,
reinterpret_cast<const hkClassMember*>(hkMonitorStreamFrameInfoClass_Members),
int(sizeof(hkMonitorStreamFrameInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkMultiThreadLockAccessTypeEnumItems[] =
{
{0, "HK_ACCESS_IGNORE"},
{1, "HK_ACCESS_RO"},
{2, "HK_ACCESS_RW"},
};
static const hkInternalClassEnumItem hkMultiThreadLockReadModeEnumItems[] =
{
{0, "THIS_OBJECT_ONLY"},
{1, "RECURSIVE"},
};
static const hkInternalClassEnum hkMultiThreadLockEnums[] = {
{"AccessType", hkMultiThreadLockAccessTypeEnumItems, 3, HK_NULL, 0 },
{"ReadMode", hkMultiThreadLockReadModeEnumItems, 2, HK_NULL, 0 }
};
const hkClassEnum* hkMultiThreadLockAccessTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkMultiThreadLockEnums[0]);
const hkClassEnum* hkMultiThreadLockReadModeEnum = reinterpret_cast<const hkClassEnum*>(&hkMultiThreadLockEnums[1]);
static hkInternalClassMember hkMultiThreadLockClass_Members[] =
{
{ "threadId", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_UINT32, 0, 0, 0, HK_NULL },
{ "lockCount", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_INT16, 0, 0, 0, HK_NULL },
{ "lockBitStack", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_UINT16, 0, 0, 0, HK_NULL }
};
hkClass hkMultiThreadLockClass(
"hkMultiThreadLock",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkMultiThreadLockEnums),
2,
reinterpret_cast<const hkClassMember*>(hkMultiThreadLockClass_Members),
int(sizeof(hkMultiThreadLockClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkAabbClass_Members[] =
{
{ "min", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "max", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkAabbClass(
"hkAabb",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkAabbClass_Members),
int(sizeof(hkAabbClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkContactPointClass_Members[] =
{
{ "position", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "separatingNormal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkContactPointClass(
"hkContactPoint",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkContactPointClass_Members),
int(sizeof(hkContactPointClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkContactPointMaterialFlagEnumEnumItems[] =
{
{1, "CONTACT_IS_NEW_AND_POTENTIAL"},
{2, "CONTACT_USES_SOLVER_PATH2"},
};
static const hkInternalClassEnum hkContactPointMaterialEnums[] = {
{"FlagEnum", hkContactPointMaterialFlagEnumEnumItems, 2, HK_NULL, 0 }
};
const hkClassEnum* hkContactPointMaterialFlagEnumEnum = reinterpret_cast<const hkClassEnum*>(&hkContactPointMaterialEnums[0]);
static hkInternalClassMember hkContactPointMaterialClass_Members[] =
{
{ "userData", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "friction", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "restitution", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "flags", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkContactPointMaterialClass(
"hkContactPointMaterial",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkContactPointMaterialEnums),
1,
reinterpret_cast<const hkClassMember*>(hkContactPointMaterialClass_Members),
int(sizeof(hkContactPointMaterialClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMotionStateClass_Members[] =
{
{ "transform", HK_NULL, HK_NULL, hkClassMember::TYPE_TRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "sweptTransform", &hkSweptTransformClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "deltaAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "objectRadius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxLinearVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxAngularVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "linearDamping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angularDamping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "deactivationClass", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "deactivationCounter", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "deactivationRefOrientation", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL }
};
hkClass hkMotionStateClass(
"hkMotionState",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMotionStateClass_Members),
int(sizeof(hkMotionStateClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSphereClass_Members[] =
{
{ "pos", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSphereClass(
"hkSphere",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSphereClass_Members),
int(sizeof(hkSphereClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSweptTransformClass_Members[] =
{
{ "centerOfMass0", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "centerOfMass1", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "rotation0", HK_NULL, HK_NULL, hkClassMember::TYPE_QUATERNION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "rotation1", HK_NULL, HK_NULL, hkClassMember::TYPE_QUATERNION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "centerOfMassLocal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSweptTransformClass(
"hkSweptTransform",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSweptTransformClass_Members),
int(sizeof(hkSweptTransformClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
extern const hkClassEnum* hkxAttributeHintEnum;
static hkInternalClassMember hkxAnimatedFloatClass_Members[] =
{
{ "floats", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "hint", HK_NULL, hkxAttributeHintEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL }
};
hkClass hkxAnimatedFloatClass(
"hkxAnimatedFloat",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxAnimatedFloatClass_Members),
int(sizeof(hkxAnimatedFloatClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
extern const hkClassEnum* hkxAttributeHintEnum;
static hkInternalClassMember hkxAnimatedMatrixClass_Members[] =
{
{ "matrices", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_MATRIX4, 0, 0, 0, HK_NULL },
{ "hint", HK_NULL, hkxAttributeHintEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL }
};
hkClass hkxAnimatedMatrixClass(
"hkxAnimatedMatrix",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxAnimatedMatrixClass_Members),
int(sizeof(hkxAnimatedMatrixClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxAnimatedQuaternionClass_Members[] =
{
{ "quaternions", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_QUATERNION, 0, 0, 0, HK_NULL }
};
hkClass hkxAnimatedQuaternionClass(
"hkxAnimatedQuaternion",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxAnimatedQuaternionClass_Members),
int(sizeof(hkxAnimatedQuaternionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
extern const hkClassEnum* hkxAttributeHintEnum;
static hkInternalClassMember hkxAnimatedVectorClass_Members[] =
{
{ "vectors", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_VECTOR4, 0, 0, 0, HK_NULL },
{ "hint", HK_NULL, hkxAttributeHintEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL }
};
hkClass hkxAnimatedVectorClass(
"hkxAnimatedVector",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxAnimatedVectorClass_Members),
int(sizeof(hkxAnimatedVectorClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkxAttributeHintEnumItems[] =
{
{0, "HINT_NONE"},
{1, "HINT_IGNORE"},
{2, "HINT_TRANSFORM"},
{4, "HINT_SCALE"},
{6, "HINT_TRANSFORM_AND_SCALE"},
{8, "HINT_FLIP"},
};
static const hkInternalClassEnum hkxAttributeEnums[] = {
{"Hint", hkxAttributeHintEnumItems, 6, HK_NULL, 0 }
};
const hkClassEnum* hkxAttributeHintEnum = reinterpret_cast<const hkClassEnum*>(&hkxAttributeEnums[0]);
static hkInternalClassMember hkxAttributeClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "value", HK_NULL, HK_NULL, hkClassMember::TYPE_VARIANT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxAttributeClass(
"hkxAttribute",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkxAttributeEnums),
1,
reinterpret_cast<const hkClassMember*>(hkxAttributeClass_Members),
int(sizeof(hkxAttributeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxAttributeGroupClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "attributes", &hkxAttributeClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkxAttributeGroupClass(
"hkxAttributeGroup",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxAttributeGroupClass_Members),
int(sizeof(hkxAttributeGroupClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxSparselyAnimatedBoolClass_Members[] =
{
{ "bools", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "times", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
hkClass hkxSparselyAnimatedBoolClass(
"hkxSparselyAnimatedBool",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxSparselyAnimatedBoolClass_Members),
int(sizeof(hkxSparselyAnimatedBoolClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxSparselyAnimatedEnumClass_Members[] =
{
{ "type", &hkClassEnumClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkxSparselyAnimatedEnumClass(
"hkxSparselyAnimatedEnum",
&hkxSparselyAnimatedIntClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxSparselyAnimatedEnumClass_Members),
int(sizeof(hkxSparselyAnimatedEnumClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxSparselyAnimatedIntClass_Members[] =
{
{ "ints", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_INT32, 0, 0, 0, HK_NULL },
{ "times", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
hkClass hkxSparselyAnimatedIntClass(
"hkxSparselyAnimatedInt",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxSparselyAnimatedIntClass_Members),
int(sizeof(hkxSparselyAnimatedIntClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxSparselyAnimatedString_StringTypeClass_Members[] =
{
{ "string", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxSparselyAnimatedStringStringTypeClass(
"hkxSparselyAnimatedStringStringType",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxSparselyAnimatedString_StringTypeClass_Members),
int(sizeof(hkxSparselyAnimatedString_StringTypeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxSparselyAnimatedStringClass_Members[] =
{
{ "strings", &hkxSparselyAnimatedStringStringTypeClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "times", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
hkClass hkxSparselyAnimatedStringClass(
"hkxSparselyAnimatedString",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxSparselyAnimatedStringClass_Members),
int(sizeof(hkxSparselyAnimatedStringClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxCameraClass_Members[] =
{
{ "from", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "focus", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "up", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "fov", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "far", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "near", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "leftHanded", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxCameraClass(
"hkxCamera",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxCameraClass_Members),
int(sizeof(hkxCameraClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxEnvironment_VariableClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "value", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxEnvironmentVariableClass(
"hkxEnvironmentVariable",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxEnvironment_VariableClass_Members),
int(sizeof(hkxEnvironment_VariableClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxEnvironmentClass_Members[] =
{
{ "variables", &hkxEnvironmentVariableClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkxEnvironmentClass(
"hkxEnvironment",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxEnvironmentClass_Members),
int(sizeof(hkxEnvironmentClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxNode_AnnotationDataClass_Members[] =
{
{ "time", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "description", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxNodeAnnotationDataClass(
"hkxNodeAnnotationData",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxNode_AnnotationDataClass_Members),
int(sizeof(hkxNode_AnnotationDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxNodeClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "object", HK_NULL, HK_NULL, hkClassMember::TYPE_VARIANT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "keyFrames", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_MATRIX4, 0, 0, 0, HK_NULL },
{ "children", &hkxNodeClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "annotations", &hkxNodeAnnotationDataClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "userProperties", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "selected", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "attributeGroups", &hkxAttributeGroupClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkxNodeClass(
"hkxNode",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxNodeClass_Members),
int(sizeof(hkxNodeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkxLightLightTypeEnumItems[] =
{
{0, "POINT_LIGHT"},
{1, "DIRECTIONAL_LIGHT"},
{2, "SPOT_LIGHT"},
};
static const hkInternalClassEnum hkxLightEnums[] = {
{"LightType", hkxLightLightTypeEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkxLightLightTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkxLightEnums[0]);
static hkInternalClassMember hkxLightClass_Members[] =
{
{ "type", HK_NULL, hkxLightLightTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "position", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "direction", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "color", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxLightClass(
"hkxLight",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkxLightEnums),
1,
reinterpret_cast<const hkClassMember*>(hkxLightClass_Members),
int(sizeof(hkxLightClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkxMaterialTextureTypeEnumItems[] =
{
{0, "TEX_UNKNOWN"},
{1, "TEX_DIFFUSE"},
{2, "TEX_REFLECTION"},
{3, "TEX_BUMP"},
{4, "TEX_NORMAL"},
{5, "TEX_DISPLACEMENT"},
};
static const hkInternalClassEnum hkxMaterialEnums[] = {
{"TextureType", hkxMaterialTextureTypeEnumItems, 6, HK_NULL, 0 }
};
const hkClassEnum* hkxMaterialTextureTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkxMaterialEnums[0]);
static hkInternalClassMember hkxMaterial_TextureStageClass_Members[] =
{
{ "texture", HK_NULL, HK_NULL, hkClassMember::TYPE_VARIANT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "usageHint", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxMaterialTextureStageClass(
"hkxMaterialTextureStage",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxMaterial_TextureStageClass_Members),
int(sizeof(hkxMaterial_TextureStageClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxMaterialClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "stages", &hkxMaterialTextureStageClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "diffuseColor", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "ambientColor", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "specularColor", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "emissiveColor", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "subMaterials", &hkxMaterialClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "extraData", HK_NULL, HK_NULL, hkClassMember::TYPE_VARIANT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxMaterialClass(
"hkxMaterial",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkxMaterialEnums),
1,
reinterpret_cast<const hkClassMember*>(hkxMaterialClass_Members),
int(sizeof(hkxMaterialClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkxMaterialEffectEffectTypeEnumItems[] =
{
{0, "EFFECT_TYPE_INVALID"},
{1, "EFFECT_TYPE_UNKNOWN"},
{2, "EFFECT_TYPE_HLSL_FX"},
{3, "EFFECT_TYPE_CG_FX"},
{4, "EFFECT_TYPE_MAX_ID"},
};
static const hkInternalClassEnum hkxMaterialEffectEnums[] = {
{"EffectType", hkxMaterialEffectEffectTypeEnumItems, 5, HK_NULL, 0 }
};
const hkClassEnum* hkxMaterialEffectEffectTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkxMaterialEffectEnums[0]);
static hkInternalClassMember hkxMaterialEffectClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "type", HK_NULL, hkxMaterialEffectEffectTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "data", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_UINT8, 0, 0, 0, HK_NULL }
};
hkClass hkxMaterialEffectClass(
"hkxMaterialEffect",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkxMaterialEffectEnums),
1,
reinterpret_cast<const hkClassMember*>(hkxMaterialEffectClass_Members),
int(sizeof(hkxMaterialEffectClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxTextureFileClass_Members[] =
{
{ "filename", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxTextureFileClass(
"hkxTextureFile",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxTextureFileClass_Members),
int(sizeof(hkxTextureFileClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxTextureInplaceClass_Members[] =
{
{ "fileType", HK_NULL, HK_NULL, hkClassMember::TYPE_CHAR, hkClassMember::TYPE_VOID, 4, 0, 0, HK_NULL },
{ "data", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_UINT8, 0, 0, 0, HK_NULL }
};
hkClass hkxTextureInplaceClass(
"hkxTextureInplace",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxTextureInplaceClass_Members),
int(sizeof(hkxTextureInplaceClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkxIndexBufferIndexTypeEnumItems[] =
{
{0, "INDEX_TYPE_INVALID"},
{1, "INDEX_TYPE_TRI_LIST"},
{2, "INDEX_TYPE_TRI_STRIP"},
{3, "INDEX_TYPE_TRI_FAN"},
{4, "INDEX_TYPE_MAX_ID"},
};
static const hkInternalClassEnum hkxIndexBufferEnums[] = {
{"IndexType", hkxIndexBufferIndexTypeEnumItems, 5, HK_NULL, 0 }
};
const hkClassEnum* hkxIndexBufferIndexTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkxIndexBufferEnums[0]);
static hkInternalClassMember hkxIndexBufferClass_Members[] =
{
{ "indexType", HK_NULL, hkxIndexBufferIndexTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "indices16", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_UINT16, 0, 0, 0, HK_NULL },
{ "indices32", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_UINT32, 0, 0, 0, HK_NULL },
{ "vertexBaseOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "length", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxIndexBufferClass(
"hkxIndexBuffer",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkxIndexBufferEnums),
1,
reinterpret_cast<const hkClassMember*>(hkxIndexBufferClass_Members),
int(sizeof(hkxIndexBufferClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxMeshClass_Members[] =
{
{ "sections", &hkxMeshSectionClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkxMeshClass(
"hkxMesh",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxMeshClass_Members),
int(sizeof(hkxMeshClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxMeshSectionClass_Members[] =
{
{ "vertexBuffer", &hkxVertexBufferClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "indexBuffers", &hkxIndexBufferClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "material", &hkxMaterialClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkxMeshSectionClass(
"hkxMeshSection",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxMeshSectionClass_Members),
int(sizeof(hkxMeshSectionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxVertexBufferClass_Members[] =
{
{ "vertexData", HK_NULL, HK_NULL, hkClassMember::TYPE_HOMOGENEOUSARRAY, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "format", &hkxVertexFormatClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkxVertexBufferClass(
"hkxVertexBuffer",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxVertexBufferClass_Members),
int(sizeof(hkxVertexBufferClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxVertexFormatClass_Members[] =
{
{ "stride", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "positionOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "normalOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tangentOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "binormalOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numBonesPerVertex", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "boneIndexOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "boneWeightOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numTextureChannels", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tFloatCoordOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tQuantizedCoordOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "colorOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxVertexFormatClass(
"hkxVertexFormat",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxVertexFormatClass_Members),
int(sizeof(hkxVertexFormatClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxVertexP4N4C1T2Class_Members[] =
{
{ "position", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "normal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "diffuse", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "u", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "v", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "padding", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxVertexP4N4C1T2Class(
"hkxVertexP4N4C1T2",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxVertexP4N4C1T2Class_Members),
int(sizeof(hkxVertexP4N4C1T2Class_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxVertexP4N4T4B4C1T2Class_Members[] =
{
{ "position", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "normal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tangent", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "binormal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "diffuse", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "u", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "v", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "padding", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxVertexP4N4T4B4C1T2Class(
"hkxVertexP4N4T4B4C1T2",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxVertexP4N4T4B4C1T2Class_Members),
int(sizeof(hkxVertexP4N4T4B4C1T2Class_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxVertexP4N4T4B4W4I4C1Q2Class_Members[] =
{
{ "position", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "normal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tangent", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "binormal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "weights", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "indices", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "diffuse", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "qu", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "qv", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxVertexP4N4T4B4W4I4C1Q2Class(
"hkxVertexP4N4T4B4W4I4C1Q2",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxVertexP4N4T4B4W4I4C1Q2Class_Members),
int(sizeof(hkxVertexP4N4T4B4W4I4C1Q2Class_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxVertexP4N4T4B4W4I4Q4Class_Members[] =
{
{ "position", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "normal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tangent", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "binormal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "weights", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "indices", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "qu0", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "qu1", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL }
};
hkClass hkxVertexP4N4T4B4W4I4Q4Class(
"hkxVertexP4N4T4B4W4I4Q4",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxVertexP4N4T4B4W4I4Q4Class_Members),
int(sizeof(hkxVertexP4N4T4B4W4I4Q4Class_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxVertexP4N4W4I4C1Q2Class_Members[] =
{
{ "position", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "normal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "weights", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "indices", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "diffuse", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "qu", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "qv", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxVertexP4N4W4I4C1Q2Class(
"hkxVertexP4N4W4I4C1Q2",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxVertexP4N4W4I4C1Q2Class_Members),
int(sizeof(hkxVertexP4N4W4I4C1Q2Class_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkxSceneClass_Members[] =
{
{ "modeller", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "asset", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "sceneLength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "rootNode", &hkxNodeClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "cameras", &hkxCameraClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "lights", &hkxLightClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "meshes", &hkxMeshClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "materials", &hkxMaterialClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "inplaceTextures", &hkxTextureInplaceClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "externalTextures", &hkxTextureFileClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "skinBindings", &hkxSkinBindingClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "appliedTransform", HK_NULL, HK_NULL, hkClassMember::TYPE_MATRIX3, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkxScene_DefaultStruct
{
int s_defaultOffsets[12];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
_hkMatrix3 m_appliedTransform;
};
const hkxScene_DefaultStruct hkxScene_Default =
{
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkxScene_DefaultStruct,m_appliedTransform)},
{1,0,0,0,0,1,0,0,0,0,1,0}
};
}
hkClass hkxSceneClass(
"hkxScene",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxSceneClass_Members),
int(sizeof(hkxSceneClass_Members)/sizeof(hkInternalClassMember)),
&hkxScene_Default
);
static hkInternalClassMember hkxSkinBindingClass_Members[] =
{
{ "mesh", &hkxMeshClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "mapping", &hkxNodeClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "bindPose", HK_NULL, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_MATRIX4, 0, 0, 0, HK_NULL },
{ "initSkinTransform", HK_NULL, HK_NULL, hkClassMember::TYPE_MATRIX4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkxSkinBindingClass(
"hkxSkinBinding",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkxSkinBindingClass_Members),
int(sizeof(hkxSkinBindingClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPackfileHeaderClass_Members[] =
{
{ "magic", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "userTag", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "fileVersion", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "layoutRules", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 4, 0, 0, HK_NULL },
{ "numSections", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "contentsSectionIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "contentsSectionOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "contentsClassNameSectionIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "contentsClassNameSectionOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "contentsVersion", HK_NULL, HK_NULL, hkClassMember::TYPE_CHAR, hkClassMember::TYPE_VOID, 16, 0, 0, HK_NULL },
{ "pad", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL }
};
hkClass hkPackfileHeaderClass(
"hkPackfileHeader",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPackfileHeaderClass_Members),
int(sizeof(hkPackfileHeaderClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPackfileSectionHeaderClass_Members[] =
{
{ "sectionTag", HK_NULL, HK_NULL, hkClassMember::TYPE_CHAR, hkClassMember::TYPE_VOID, 19, 0, 0, HK_NULL },
{ "nullByte", HK_NULL, HK_NULL, hkClassMember::TYPE_CHAR, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "absoluteDataStart", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "localFixupsOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "globalFixupsOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "virtualFixupsOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "exportsOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "importsOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "endOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPackfileSectionHeaderClass(
"hkPackfileSectionHeader",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPackfileSectionHeaderClass_Members),
int(sizeof(hkPackfileSectionHeaderClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkRootLevelContainer_NamedVariantClass_Members[] =
{
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "className", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "variant", HK_NULL, HK_NULL, hkClassMember::TYPE_VARIANT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkRootLevelContainerNamedVariantClass(
"hkRootLevelContainerNamedVariant",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkRootLevelContainer_NamedVariantClass_Members),
int(sizeof(hkRootLevelContainer_NamedVariantClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkRootLevelContainerClass_Members[] =
{
{ "namedVariants", &hkRootLevelContainerNamedVariantClass, HK_NULL, hkClassMember::TYPE_SIMPLEARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkRootLevelContainerClass(
"hkRootLevelContainer",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkRootLevelContainerClass_Members),
int(sizeof(hkRootLevelContainerClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVersioningExceptionsArray_VersioningExceptionClass_Members[] =
{
{ "className", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "oldSignature", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "newSignature", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVersioningExceptionsArrayVersioningExceptionClass(
"hkVersioningExceptionsArrayVersioningException",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVersioningExceptionsArray_VersioningExceptionClass_Members),
int(sizeof(hkVersioningExceptionsArray_VersioningExceptionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVersioningExceptionsArrayClass_Members[] =
{
{ "exceptions", &hkVersioningExceptionsArrayVersioningExceptionClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkVersioningExceptionsArrayClass(
"hkVersioningExceptionsArray",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVersioningExceptionsArrayClass_Members),
int(sizeof(hkVersioningExceptionsArrayClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkRagdollInstanceClass_Members[] =
{
{ "rigidBodies", &hkRigidBodyClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "constraints", &hkConstraintInstanceClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "skeleton", &hkSkeletonClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkRagdollInstanceClass(
"hkRagdollInstance",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkRagdollInstanceClass_Members),
int(sizeof(hkRagdollInstanceClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkCdBodyClass_Members[] =
{
{ "shape", &hkShapeClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "shapeKey", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "motion", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "parent", &hkCdBodyClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkCdBodyClass(
"hkCdBody",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkCdBodyClass_Members),
int(sizeof(hkCdBodyClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkCollidableClass_Members[] =
{
{ "ownerOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "broadPhaseHandle", &hkTypedBroadPhaseHandleClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "allowedPenetrationDepth", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkCollidableClass(
"hkCollidable",
&hkCdBodyClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkCollidableClass_Members),
int(sizeof(hkCollidableClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkShapeCollectionFilterClass(
"hkShapeCollectionFilter",
HK_NULL,
0,
HK_NULL,
1,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkTypedBroadPhaseHandleClass_Members[] =
{
{ "type", HK_NULL, HK_NULL, hkClassMember::TYPE_INT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "ownerOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "objectQualityType", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "collisionFilterInfo", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkTypedBroadPhaseHandleClass(
"hkTypedBroadPhaseHandle",
&hkBroadPhaseHandleClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkTypedBroadPhaseHandleClass_Members),
int(sizeof(hkTypedBroadPhaseHandleClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkCollidableCollidableFilterClass(
"hkCollidableCollidableFilter",
HK_NULL,
0,
HK_NULL,
1,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkCollisionFilterClass(
"hkCollisionFilter",
&hkReferencedObjectClass,
0,
HK_NULL,
4,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static const hkInternalClassEnumItem hkConvexListFilterConvexListCollisionTypeEnumItems[] =
{
{0, "TREAT_CONVEX_LIST_AS_NORMAL"},
{1, "TREAT_CONVEX_LIST_AS_LIST"},
{2, "TREAT_CONVEX_LIST_AS_CONVEX"},
};
static const hkInternalClassEnum hkConvexListFilterEnums[] = {
{"ConvexListCollisionType", hkConvexListFilterConvexListCollisionTypeEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkConvexListFilterConvexListCollisionTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkConvexListFilterEnums[0]);
hkClass hkConvexListFilterClass(
"hkConvexListFilter",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkConvexListFilterEnums),
1,
HK_NULL,
0,
HK_NULL
);
hkClass hkRayCollidableFilterClass(
"hkRayCollidableFilter",
HK_NULL,
0,
HK_NULL,
1,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkDefaultConvexListFilterClass(
"hkDefaultConvexListFilter",
&hkConvexListFilterClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkGroupFilterClass_Members[] =
{
{ "nextFreeSystemGroup", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "collisionLookupTable", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 32, 0, 0, HK_NULL }
};
hkClass hkGroupFilterClass(
"hkGroupFilter",
&hkCollisionFilterClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkGroupFilterClass_Members),
int(sizeof(hkGroupFilterClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkCollisionFilterListClass_Members[] =
{
{ "collisionFilters", &hkCollisionFilterClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkCollisionFilterListClass(
"hkCollisionFilterList",
&hkCollisionFilterClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkCollisionFilterListClass_Members),
int(sizeof(hkCollisionFilterListClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkNullCollisionFilterClass(
"hkNullCollisionFilter",
&hkCollisionFilterClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkRayShapeCollectionFilterClass(
"hkRayShapeCollectionFilter",
HK_NULL,
0,
HK_NULL,
1,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkShapeClass_Members[] =
{
{ "userData", HK_NULL, HK_NULL, hkClassMember::TYPE_ULONG, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkShapeClass(
"hkShape",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkShapeClass_Members),
int(sizeof(hkShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkShapeContainerClass(
"hkShapeContainer",
HK_NULL,
0,
HK_NULL,
1,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkSingleShapeContainerClass_Members[] =
{
{ "childShape", &hkShapeClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkSingleShapeContainerClass(
"hkSingleShapeContainer",
&hkShapeContainerClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSingleShapeContainerClass_Members),
int(sizeof(hkSingleShapeContainerClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkShapeRayCastInputClass_Members[] =
{
{ "from", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "to", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "filterInfo", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "rayShapeCollectionFilter", &hkRayShapeCollectionFilterClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkShapeRayCastInputClass(
"hkShapeRayCastInput",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkShapeRayCastInputClass_Members),
int(sizeof(hkShapeRayCastInputClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBoxShapeClass_Members[] =
{
{ "halfExtents", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBoxShapeClass(
"hkBoxShape",
&hkConvexShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBoxShapeClass_Members),
int(sizeof(hkBoxShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBvShapeClass_Members[] =
{
{ "boundingVolumeShape", &hkShapeClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "childShape", &hkSingleShapeContainerClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBvShapeClass(
"hkBvShape",
&hkShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBvShapeClass_Members),
int(sizeof(hkBvShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBvTreeShapeClass_Members[] =
{
{ "child", &hkSingleShapeContainerClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBvTreeShapeClass(
"hkBvTreeShape",
&hkShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBvTreeShapeClass_Members),
int(sizeof(hkBvTreeShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkCapsuleShapeRayHitTypeEnumItems[] =
{
{0, "HIT_CAP0"},
{1, "HIT_CAP1"},
{2, "HIT_BODY"},
};
static const hkInternalClassEnum hkCapsuleShapeEnums[] = {
{"RayHitType", hkCapsuleShapeRayHitTypeEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkCapsuleShapeRayHitTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkCapsuleShapeEnums[0]);
static hkInternalClassMember hkCapsuleShapeClass_Members[] =
{
{ "vertexA", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "vertexB", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkCapsuleShapeClass(
"hkCapsuleShape",
&hkConvexShapeClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkCapsuleShapeEnums),
1,
reinterpret_cast<const hkClassMember*>(hkCapsuleShapeClass_Members),
int(sizeof(hkCapsuleShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkShapeCollectionClass_Members[] =
{
{ "disableWelding", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkShapeCollectionClass(
"hkShapeCollection",
&hkShapeClass,
0,
HK_NULL,
1,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkShapeCollectionClass_Members),
int(sizeof(hkShapeCollectionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkConvexShapeClass_Members[] =
{
{ "radius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkConvexShapeClass(
"hkConvexShape",
&hkSphereRepShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConvexShapeClass_Members),
int(sizeof(hkConvexShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkConvexListShapeClass_Members[] =
{
{ "minDistanceToUseConvexHullForGetClosestPoints", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "aabbHalfExtents", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "aabbCenter", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "useCachedAabb", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "childShapes", &hkConvexShapeClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkConvexListShape_DefaultStruct
{
int s_defaultOffsets[5];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
bool m_useCachedAabb;
};
const hkConvexListShape_DefaultStruct hkConvexListShape_Default =
{
{-1,-1,-1,HK_OFFSET_OF(hkConvexListShape_DefaultStruct,m_useCachedAabb),-1},
false
};
}
hkClass hkConvexListShapeClass(
"hkConvexListShape",
&hkConvexShapeClass,
0,
HK_NULL,
1,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConvexListShapeClass_Members),
int(sizeof(hkConvexListShapeClass_Members)/sizeof(hkInternalClassMember)),
&hkConvexListShape_Default
);
static hkInternalClassMember hkConvexPieceMeshShapeClass_Members[] =
{
{ "convexPieceStream", &hkConvexPieceStreamDataClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "displayMesh", &hkShapeCollectionClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "radius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkConvexPieceMeshShapeClass(
"hkConvexPieceMeshShape",
&hkShapeCollectionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConvexPieceMeshShapeClass_Members),
int(sizeof(hkConvexPieceMeshShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkConvexTransformShapeClass_Members[] =
{
{ "childShape", &hkSingleShapeContainerClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "transform", HK_NULL, HK_NULL, hkClassMember::TYPE_TRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkConvexTransformShapeClass(
"hkConvexTransformShape",
&hkConvexShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConvexTransformShapeClass_Members),
int(sizeof(hkConvexTransformShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkConvexTranslateShapeClass_Members[] =
{
{ "childShape", &hkSingleShapeContainerClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "translation", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkConvexTranslateShapeClass(
"hkConvexTranslateShape",
&hkConvexShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConvexTranslateShapeClass_Members),
int(sizeof(hkConvexTranslateShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkConvexVerticesShape_FourVectorsClass_Members[] =
{
{ "x", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "y", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "z", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkConvexVerticesShapeFourVectorsClass(
"hkConvexVerticesShapeFourVectors",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConvexVerticesShape_FourVectorsClass_Members),
int(sizeof(hkConvexVerticesShape_FourVectorsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkConvexVerticesShapeClass_Members[] =
{
{ "aabbHalfExtents", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "aabbCenter", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "rotatedVertices", &hkConvexVerticesShapeFourVectorsClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "numVertices", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "planeEquations", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_VECTOR4, 0, 0, 0, HK_NULL }
};
hkClass hkConvexVerticesShapeClass(
"hkConvexVerticesShape",
&hkConvexShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConvexVerticesShapeClass_Members),
int(sizeof(hkConvexVerticesShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkCylinderShapeVertexIdEncodingEnumItems[] =
{
{7, "VERTEX_ID_ENCODING_IS_BASE_A_SHIFT"},
{6, "VERTEX_ID_ENCODING_SIN_SIGN_SHIFT"},
{5, "VERTEX_ID_ENCODING_COS_SIGN_SHIFT"},
{4, "VERTEX_ID_ENCODING_IS_SIN_LESSER_SHIFT"},
{0x0f, "VERTEX_ID_ENCODING_VALUE_MASK"},
};
static const hkInternalClassEnum hkCylinderShapeEnums[] = {
{"VertexIdEncoding", hkCylinderShapeVertexIdEncodingEnumItems, 5, HK_NULL, 0 }
};
const hkClassEnum* hkCylinderShapeVertexIdEncodingEnum = reinterpret_cast<const hkClassEnum*>(&hkCylinderShapeEnums[0]);
static hkInternalClassMember hkCylinderShapeClass_Members[] =
{
{ "cylRadius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "cylBaseRadiusFactorForHeightFieldCollisions", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "vertexA", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "vertexB", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "perpendicular1", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "perpendicular2", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkCylinderShape_DefaultStruct
{
int s_defaultOffsets[6];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_cylBaseRadiusFactorForHeightFieldCollisions;
};
const hkCylinderShape_DefaultStruct hkCylinderShape_Default =
{
{-1,HK_OFFSET_OF(hkCylinderShape_DefaultStruct,m_cylBaseRadiusFactorForHeightFieldCollisions),-1,-1,-1,-1},
0.8f
};
}
hkClass hkCylinderShapeClass(
"hkCylinderShape",
&hkConvexShapeClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkCylinderShapeEnums),
1,
reinterpret_cast<const hkClassMember*>(hkCylinderShapeClass_Members),
int(sizeof(hkCylinderShapeClass_Members)/sizeof(hkInternalClassMember)),
&hkCylinderShape_Default
);
static const hkInternalClassEnumItem hkExtendedMeshShapeIndexStridingTypeEnumItems[] =
{
{0, "INDICES_INVALID"},
{1, "INDICES_INT16"},
{2, "INDICES_INT32"},
{3, "INDICES_MAX_ID"},
};
static const hkInternalClassEnumItem hkExtendedMeshShapeMaterialIndexStridingTypeEnumItems[] =
{
{0, "MATERIAL_INDICES_INVALID"},
{1, "MATERIAL_INDICES_INT8"},
{2, "MATERIAL_INDICES_INT16"},
{3, "MATERIAL_INDICES_MAX_ID"},
};
static const hkInternalClassEnumItem hkExtendedMeshShapeSubpartTypeEnumItems[] =
{
{0, "SUBPART_TRIANGLES"},
{1, "SUBPART_SHAPE"},
};
static const hkInternalClassEnum hkExtendedMeshShapeEnums[] = {
{"IndexStridingType", hkExtendedMeshShapeIndexStridingTypeEnumItems, 4, HK_NULL, 0 },
{"MaterialIndexStridingType", hkExtendedMeshShapeMaterialIndexStridingTypeEnumItems, 4, HK_NULL, 0 },
{"SubpartType", hkExtendedMeshShapeSubpartTypeEnumItems, 2, HK_NULL, 0 }
};
const hkClassEnum* hkExtendedMeshShapeIndexStridingTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkExtendedMeshShapeEnums[0]);
const hkClassEnum* hkExtendedMeshShapeMaterialIndexStridingTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkExtendedMeshShapeEnums[1]);
const hkClassEnum* hkExtendedMeshShapeSubpartTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkExtendedMeshShapeEnums[2]);
static hkInternalClassMember hkExtendedMeshShape_SubpartClass_Members[] =
{
{ "type", HK_NULL, hkExtendedMeshShapeSubpartTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "numShapes", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "materialIndexStridingType", HK_NULL, hkExtendedMeshShapeIndexStridingTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "materialIndexBase", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "materialIndexStriding", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "materialBase", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "materialStriding", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numMaterials", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkExtendedMeshShapeSubpartClass(
"hkExtendedMeshShapeSubpart",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkExtendedMeshShape_SubpartClass_Members),
int(sizeof(hkExtendedMeshShape_SubpartClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkExtendedMeshShape_TrianglesSubpartClass_Members[] =
{
{ "vertexBase", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "vertexStriding", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numVertices", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "indexBase", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "stridingType", HK_NULL, hkExtendedMeshShapeIndexStridingTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "indexStriding", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkExtendedMeshShapeTrianglesSubpartClass(
"hkExtendedMeshShapeTrianglesSubpart",
&hkExtendedMeshShapeSubpartClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkExtendedMeshShape_TrianglesSubpartClass_Members),
int(sizeof(hkExtendedMeshShape_TrianglesSubpartClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkExtendedMeshShape_ShapesSubpartClass_Members[] =
{
{ "childShapes", HK_NULL, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "offsetSet", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "rotationSet", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "transform", HK_NULL, HK_NULL, hkClassMember::TYPE_TRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkExtendedMeshShapeShapesSubpartClass(
"hkExtendedMeshShapeShapesSubpart",
&hkExtendedMeshShapeSubpartClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkExtendedMeshShape_ShapesSubpartClass_Members),
int(sizeof(hkExtendedMeshShape_ShapesSubpartClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkExtendedMeshShapeClass_Members[] =
{
{ "scaling", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numBitsForSubpartIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "trianglesSubparts", &hkExtendedMeshShapeTrianglesSubpartClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "shapesSubparts", &hkExtendedMeshShapeShapesSubpartClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "radius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "pad", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 3, 0, 0, HK_NULL }
};
hkClass hkExtendedMeshShapeClass(
"hkExtendedMeshShape",
&hkShapeCollectionClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkExtendedMeshShapeEnums),
3,
reinterpret_cast<const hkClassMember*>(hkExtendedMeshShapeClass_Members),
int(sizeof(hkExtendedMeshShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkFastMeshShapeClass(
"hkFastMeshShape",
&hkMeshShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkHeightFieldShapeClass(
"hkHeightFieldShape",
&hkShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkListShape_ChildInfoClass_Members[] =
{
{ "shape", &hkShapeClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "collisionFilterInfo", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkListShapeChildInfoClass(
"hkListShapeChildInfo",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkListShape_ChildInfoClass_Members),
int(sizeof(hkListShape_ChildInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkListShapeClass_Members[] =
{
{ "childInfo", &hkListShapeChildInfoClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkListShapeClass(
"hkListShape",
&hkShapeCollectionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkListShapeClass_Members),
int(sizeof(hkListShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMeshMaterialClass_Members[] =
{
{ "filterInfo", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMeshMaterialClass(
"hkMeshMaterial",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMeshMaterialClass_Members),
int(sizeof(hkMeshMaterialClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkMeshShapeIndexStridingTypeEnumItems[] =
{
{0, "INDICES_INVALID"},
{1, "INDICES_INT16"},
{2, "INDICES_INT32"},
{3, "INDICES_MAX_ID"},
};
static const hkInternalClassEnumItem hkMeshShapeMaterialIndexStridingTypeEnumItems[] =
{
{0, "MATERIAL_INDICES_INVALID"},
{1, "MATERIAL_INDICES_INT8"},
{2, "MATERIAL_INDICES_INT16"},
{3, "MATERIAL_INDICES_MAX_ID"},
};
static const hkInternalClassEnum hkMeshShapeEnums[] = {
{"IndexStridingType", hkMeshShapeIndexStridingTypeEnumItems, 4, HK_NULL, 0 },
{"MaterialIndexStridingType", hkMeshShapeMaterialIndexStridingTypeEnumItems, 4, HK_NULL, 0 }
};
const hkClassEnum* hkMeshShapeIndexStridingTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkMeshShapeEnums[0]);
const hkClassEnum* hkMeshShapeMaterialIndexStridingTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkMeshShapeEnums[1]);
static hkInternalClassMember hkMeshShape_SubpartClass_Members[] =
{
{ "vertexBase", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "vertexStriding", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numVertices", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "indexBase", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "stridingType", HK_NULL, hkMeshShapeIndexStridingTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "materialIndexStridingType", HK_NULL, hkMeshShapeIndexStridingTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "indexStriding", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numTriangles", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "materialIndexBase", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "materialIndexStriding", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "materialBase", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "materialStriding", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numMaterials", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMeshShapeSubpartClass(
"hkMeshShapeSubpart",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMeshShape_SubpartClass_Members),
int(sizeof(hkMeshShape_SubpartClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMeshShapeClass_Members[] =
{
{ "scaling", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numBitsForSubpartIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "subparts", &hkMeshShapeSubpartClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "radius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "pad", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 3, 0, 0, HK_NULL }
};
hkClass hkMeshShapeClass(
"hkMeshShape",
&hkShapeCollectionClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkMeshShapeEnums),
2,
reinterpret_cast<const hkClassMember*>(hkMeshShapeClass_Members),
int(sizeof(hkMeshShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMoppBvTreeShapeClass_Members[] =
{
{ "code", &hkMoppCodeClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkMoppBvTreeShapeClass(
"hkMoppBvTreeShape",
&hkBvTreeShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMoppBvTreeShapeClass_Members),
int(sizeof(hkMoppBvTreeShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMultiRayShape_RayClass_Members[] =
{
{ "start", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "end", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMultiRayShapeRayClass(
"hkMultiRayShapeRay",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMultiRayShape_RayClass_Members),
int(sizeof(hkMultiRayShape_RayClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMultiRayShapeClass_Members[] =
{
{ "rays", &hkMultiRayShapeRayClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "rayPenetrationDistance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMultiRayShapeClass(
"hkMultiRayShape",
&hkShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMultiRayShapeClass_Members),
int(sizeof(hkMultiRayShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMultiSphereShapeClass_Members[] =
{
{ "numSpheres", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "spheres", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 8, 0, 0, HK_NULL }
};
hkClass hkMultiSphereShapeClass(
"hkMultiSphereShape",
&hkSphereRepShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMultiSphereShapeClass_Members),
int(sizeof(hkMultiSphereShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkPhantomCallbackShapeClass(
"hkPhantomCallbackShape",
&hkShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkPlaneShapeClass_Members[] =
{
{ "plane", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "aabbCenter", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "aabbHalfExtents", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPlaneShapeClass(
"hkPlaneShape",
&hkHeightFieldShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPlaneShapeClass_Members),
int(sizeof(hkPlaneShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSampledHeightFieldShapeClass_Members[] =
{
{ "xRes", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "zRes", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "heightCenter", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "intToFloatScale", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "floatToIntScale", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "floatToIntOffsetFloorCorrected", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "extents", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSampledHeightFieldShapeClass(
"hkSampledHeightFieldShape",
&hkHeightFieldShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSampledHeightFieldShapeClass_Members),
int(sizeof(hkSampledHeightFieldShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSimpleMeshShape_TriangleClass_Members[] =
{
{ "a", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "b", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "c", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSimpleMeshShapeTriangleClass(
"hkSimpleMeshShapeTriangle",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSimpleMeshShape_TriangleClass_Members),
int(sizeof(hkSimpleMeshShape_TriangleClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSimpleMeshShapeClass_Members[] =
{
{ "vertices", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_VECTOR4, 0, 0, 0, HK_NULL },
{ "triangles", &hkSimpleMeshShapeTriangleClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "materialIndices", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT8, 0, 0, 0, HK_NULL },
{ "radius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSimpleMeshShapeClass(
"hkSimpleMeshShape",
&hkShapeCollectionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSimpleMeshShapeClass_Members),
int(sizeof(hkSimpleMeshShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkSphereShapeClass(
"hkSphereShape",
&hkConvexShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkSphereRepShapeClass(
"hkSphereRepShape",
&hkShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkStorageMeshShape_SubpartStorageClass_Members[] =
{
{ "vertices", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "indices16", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT16, 0, 0, 0, HK_NULL },
{ "indices32", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT32, 0, 0, 0, HK_NULL },
{ "materialIndices", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT8, 0, 0, 0, HK_NULL },
{ "materials", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT32, 0, 0, 0, HK_NULL },
{ "materialIndices16", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT16, 0, 0, 0, HK_NULL }
};
hkClass hkStorageMeshShapeSubpartStorageClass(
"hkStorageMeshShapeSubpartStorage",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkStorageMeshShape_SubpartStorageClass_Members),
int(sizeof(hkStorageMeshShape_SubpartStorageClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkStorageMeshShapeClass_Members[] =
{
{ "storage", &hkStorageMeshShapeSubpartStorageClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkStorageMeshShapeClass(
"hkStorageMeshShape",
&hkMeshShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkStorageMeshShapeClass_Members),
int(sizeof(hkStorageMeshShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkStorageSampledHeightFieldShapeClass_Members[] =
{
{ "storage", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "triangleFlip", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkStorageSampledHeightFieldShapeClass(
"hkStorageSampledHeightFieldShape",
&hkSampledHeightFieldShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkStorageSampledHeightFieldShapeClass_Members),
int(sizeof(hkStorageSampledHeightFieldShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkTransformShapeClass_Members[] =
{
{ "childShape", &hkSingleShapeContainerClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "rotation", HK_NULL, HK_NULL, hkClassMember::TYPE_QUATERNION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "transform", HK_NULL, HK_NULL, hkClassMember::TYPE_TRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkTransformShapeClass(
"hkTransformShape",
&hkShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkTransformShapeClass_Members),
int(sizeof(hkTransformShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkTriangleShapeClass_Members[] =
{
{ "vertexA", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "vertexB", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "vertexC", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkTriangleShapeClass(
"hkTriangleShape",
&hkConvexShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkTriangleShapeClass_Members),
int(sizeof(hkTriangleShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkTriSampledHeightFieldBvTreeShapeClass_Members[] =
{
{ "wantAabbRejectionTest", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkTriSampledHeightFieldBvTreeShapeClass(
"hkTriSampledHeightFieldBvTreeShape",
&hkBvTreeShapeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkTriSampledHeightFieldBvTreeShapeClass_Members),
int(sizeof(hkTriSampledHeightFieldBvTreeShapeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkTriSampledHeightFieldCollectionClass_Members[] =
{
{ "heightfield", &hkSampledHeightFieldShapeClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "radius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkTriSampledHeightFieldCollectionClass(
"hkTriSampledHeightFieldCollection",
&hkShapeCollectionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkTriSampledHeightFieldCollectionClass_Members),
int(sizeof(hkTriSampledHeightFieldCollectionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkConstraintAtomAtomTypeEnumItems[] =
{
{0, "TYPE_INVALID"},
{1, "TYPE_BRIDGE"},
{2, "TYPE_SET_LOCAL_TRANSFORMS"},
{3, "TYPE_SET_LOCAL_TRANSLATIONS"},
{4, "TYPE_SET_LOCAL_ROTATIONS"},
{5, "TYPE_BALL_SOCKET"},
{6, "TYPE_STIFF_SPRING"},
{7, "TYPE_LIN"},
{8, "TYPE_LIN_SOFT"},
{9, "TYPE_LIN_LIMIT"},
{10, "TYPE_LIN_FRICTION"},
{11, "TYPE_LIN_MOTOR"},
{12, "TYPE_2D_ANG"},
{13, "TYPE_ANG"},
{14, "TYPE_ANG_LIMIT"},
{15, "TYPE_TWIST_LIMIT"},
{16, "TYPE_CONE_LIMIT"},
{17, "TYPE_ANG_FRICTION"},
{18, "TYPE_ANG_MOTOR"},
{19, "TYPE_RAGDOLL_MOTOR"},
{20, "TYPE_PULLEY"},
{21, "TYPE_OVERWRITE_PIVOT"},
{22, "TYPE_CONTACT"},
{23, "TYPE_MODIFIER_SOFT_CONTACT"},
{24, "TYPE_MODIFIER_MASS_CHANGER"},
{25, "TYPE_MODIFIER_VISCOUS_SURFACE"},
{26, "TYPE_MODIFIER_MOVING_SURFACE"},
{27, "TYPE_MAX"},
};
static const hkInternalClassEnumItem hkConstraintAtomCallbackRequestEnumItems[] =
{
{0, "CALLBACK_REQUEST_NONE"},
{1, "CALLBACK_REQUEST_CONTACT_POINT"},
{2, "CALLBACK_REQUEST_SETUP_PPU_ONLY"},
};
static const hkInternalClassEnum hkConstraintAtomEnums[] = {
{"AtomType", hkConstraintAtomAtomTypeEnumItems, 28, HK_NULL, 0 },
{"CallbackRequest", hkConstraintAtomCallbackRequestEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkConstraintAtomAtomTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkConstraintAtomEnums[0]);
const hkClassEnum* hkConstraintAtomCallbackRequestEnum = reinterpret_cast<const hkClassEnum*>(&hkConstraintAtomEnums[1]);
static hkInternalClassMember hkConstraintAtomClass_Members[] =
{
{ "type", HK_NULL, hkConstraintAtomAtomTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_16, 0, HK_NULL }
};
hkClass hkConstraintAtomClass(
"hkConstraintAtom",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkConstraintAtomEnums),
2,
reinterpret_cast<const hkClassMember*>(hkConstraintAtomClass_Members),
int(sizeof(hkConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBridgeConstraintAtomClass_Members[] =
{
{ "buildJacobianFunc", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "constraintData", &hkConstraintDataClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkBridgeConstraintAtomClass(
"hkBridgeConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBridgeConstraintAtomClass_Members),
int(sizeof(hkBridgeConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBridgeAtomsClass_Members[] =
{
{ "bridgeAtom", &hkBridgeConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBridgeAtomsClass(
"hkBridgeAtoms",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBridgeAtomsClass_Members),
int(sizeof(hkBridgeAtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkBallSocketConstraintAtomClass(
"hkBallSocketConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkStiffSpringConstraintAtomClass_Members[] =
{
{ "length", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkStiffSpringConstraintAtomClass(
"hkStiffSpringConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkStiffSpringConstraintAtomClass_Members),
int(sizeof(hkStiffSpringConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSetLocalTransformsConstraintAtomClass_Members[] =
{
{ "transformA", HK_NULL, HK_NULL, hkClassMember::TYPE_TRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "transformB", HK_NULL, HK_NULL, hkClassMember::TYPE_TRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSetLocalTransformsConstraintAtomClass(
"hkSetLocalTransformsConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSetLocalTransformsConstraintAtomClass_Members),
int(sizeof(hkSetLocalTransformsConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSetLocalTranslationsConstraintAtomClass_Members[] =
{
{ "translationA", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "translationB", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSetLocalTranslationsConstraintAtomClass(
"hkSetLocalTranslationsConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSetLocalTranslationsConstraintAtomClass_Members),
int(sizeof(hkSetLocalTranslationsConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSetLocalRotationsConstraintAtomClass_Members[] =
{
{ "rotationA", HK_NULL, HK_NULL, hkClassMember::TYPE_ROTATION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "rotationB", HK_NULL, HK_NULL, hkClassMember::TYPE_ROTATION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSetLocalRotationsConstraintAtomClass(
"hkSetLocalRotationsConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSetLocalRotationsConstraintAtomClass_Members),
int(sizeof(hkSetLocalRotationsConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkOverwritePivotConstraintAtomClass_Members[] =
{
{ "copyToPivotBFromPivotA", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkOverwritePivotConstraintAtomClass(
"hkOverwritePivotConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkOverwritePivotConstraintAtomClass_Members),
int(sizeof(hkOverwritePivotConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkLinConstraintAtomClass_Members[] =
{
{ "axisIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkLinConstraintAtomClass(
"hkLinConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkLinConstraintAtomClass_Members),
int(sizeof(hkLinConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkLinSoftConstraintAtomClass_Members[] =
{
{ "axisIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tau", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "damping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkLinSoftConstraintAtomClass(
"hkLinSoftConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkLinSoftConstraintAtomClass_Members),
int(sizeof(hkLinSoftConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkLinLimitConstraintAtomClass_Members[] =
{
{ "axisIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "min", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "max", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkLinLimitConstraintAtomClass(
"hkLinLimitConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkLinLimitConstraintAtomClass_Members),
int(sizeof(hkLinLimitConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hk2dAngConstraintAtomClass_Members[] =
{
{ "freeRotationAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hk2dAngConstraintAtomClass(
"hk2dAngConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hk2dAngConstraintAtomClass_Members),
int(sizeof(hk2dAngConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkAngConstraintAtomClass_Members[] =
{
{ "firstConstrainedAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numConstrainedAxes", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkAngConstraintAtomClass(
"hkAngConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkAngConstraintAtomClass_Members),
int(sizeof(hkAngConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkAngLimitConstraintAtomClass_Members[] =
{
{ "isEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "limitAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "minAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angularLimitsTauFactor", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkAngLimitConstraintAtom_DefaultStruct
{
int s_defaultOffsets[5];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_angularLimitsTauFactor;
};
const hkAngLimitConstraintAtom_DefaultStruct hkAngLimitConstraintAtom_Default =
{
{-1,-1,-1,-1,HK_OFFSET_OF(hkAngLimitConstraintAtom_DefaultStruct,m_angularLimitsTauFactor)},
1.0
};
}
hkClass hkAngLimitConstraintAtomClass(
"hkAngLimitConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkAngLimitConstraintAtomClass_Members),
int(sizeof(hkAngLimitConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
&hkAngLimitConstraintAtom_Default
);
static hkInternalClassMember hkTwistLimitConstraintAtomClass_Members[] =
{
{ "isEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "twistAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "refAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "minAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angularLimitsTauFactor", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkTwistLimitConstraintAtom_DefaultStruct
{
int s_defaultOffsets[6];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_angularLimitsTauFactor;
};
const hkTwistLimitConstraintAtom_DefaultStruct hkTwistLimitConstraintAtom_Default =
{
{-1,-1,-1,-1,-1,HK_OFFSET_OF(hkTwistLimitConstraintAtom_DefaultStruct,m_angularLimitsTauFactor)},
1.0
};
}
hkClass hkTwistLimitConstraintAtomClass(
"hkTwistLimitConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkTwistLimitConstraintAtomClass_Members),
int(sizeof(hkTwistLimitConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
&hkTwistLimitConstraintAtom_Default
);
static const hkInternalClassEnumItem hkConeLimitConstraintAtomMeasurementModeEnumItems[] =
{
{0, "ZERO_WHEN_VECTORS_ALIGNED"},
{1, "ZERO_WHEN_VECTORS_PERPENDICULAR"},
};
static const hkInternalClassEnum hkConeLimitConstraintAtomEnums[] = {
{"MeasurementMode", hkConeLimitConstraintAtomMeasurementModeEnumItems, 2, HK_NULL, 0 }
};
const hkClassEnum* hkConeLimitConstraintAtomMeasurementModeEnum = reinterpret_cast<const hkClassEnum*>(&hkConeLimitConstraintAtomEnums[0]);
static hkInternalClassMember hkConeLimitConstraintAtomClass_Members[] =
{
{ "isEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "twistAxisInA", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "refAxisInB", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angleMeasurementMode", HK_NULL, hkConeLimitConstraintAtomMeasurementModeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "minAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angularLimitsTauFactor", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkConeLimitConstraintAtom_DefaultStruct
{
int s_defaultOffsets[7];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_angularLimitsTauFactor;
};
const hkConeLimitConstraintAtom_DefaultStruct hkConeLimitConstraintAtom_Default =
{
{-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkConeLimitConstraintAtom_DefaultStruct,m_angularLimitsTauFactor)},
1.0
};
}
hkClass hkConeLimitConstraintAtomClass(
"hkConeLimitConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkConeLimitConstraintAtomEnums),
1,
reinterpret_cast<const hkClassMember*>(hkConeLimitConstraintAtomClass_Members),
int(sizeof(hkConeLimitConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
&hkConeLimitConstraintAtom_Default
);
static hkInternalClassMember hkAngFrictionConstraintAtomClass_Members[] =
{
{ "isEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "firstFrictionAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numFrictionAxes", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxFrictionTorque", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkAngFrictionConstraintAtomClass(
"hkAngFrictionConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkAngFrictionConstraintAtomClass_Members),
int(sizeof(hkAngFrictionConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkAngMotorConstraintAtomClass_Members[] =
{
{ "isEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "motorAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "initializedOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "previousTargetAngleOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "correspondingAngLimitSolverResultOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "targetAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "motor", &hkConstraintMotorClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkAngMotorConstraintAtomClass(
"hkAngMotorConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkAngMotorConstraintAtomClass_Members),
int(sizeof(hkAngMotorConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkRagdollMotorConstraintAtomClass_Members[] =
{
{ "isEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "initializedOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "previousTargetAnglesOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "targetFrameAinB", HK_NULL, HK_NULL, hkClassMember::TYPE_MATRIX3, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "motors", &hkConstraintMotorClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 3, 0, 0, HK_NULL }
};
hkClass hkRagdollMotorConstraintAtomClass(
"hkRagdollMotorConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkRagdollMotorConstraintAtomClass_Members),
int(sizeof(hkRagdollMotorConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkLinFrictionConstraintAtomClass_Members[] =
{
{ "isEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "frictionAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxFrictionForce", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkLinFrictionConstraintAtomClass(
"hkLinFrictionConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkLinFrictionConstraintAtomClass_Members),
int(sizeof(hkLinFrictionConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkLinMotorConstraintAtomClass_Members[] =
{
{ "isEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "motorAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "initializedOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "previousTargetPositionOffset", HK_NULL, HK_NULL, hkClassMember::TYPE_INT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "targetPosition", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "motor", &hkConstraintMotorClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkLinMotorConstraintAtomClass(
"hkLinMotorConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkLinMotorConstraintAtomClass_Members),
int(sizeof(hkLinMotorConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPulleyConstraintAtomClass_Members[] =
{
{ "fixedPivotAinWorld", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "fixedPivotBinWorld", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "ropeLength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "leverageOnBodyB", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPulleyConstraintAtomClass(
"hkPulleyConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPulleyConstraintAtomClass_Members),
int(sizeof(hkPulleyConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkModifierConstraintAtomClass_Members[] =
{
{ "modifierAtomSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "childSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "child", &hkConstraintAtomClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkModifierConstraintAtomClass(
"hkModifierConstraintAtom",
&hkConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkModifierConstraintAtomClass_Members),
int(sizeof(hkModifierConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSoftContactModifierConstraintAtomClass_Members[] =
{
{ "tau", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxAcceleration", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSoftContactModifierConstraintAtomClass(
"hkSoftContactModifierConstraintAtom",
&hkModifierConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSoftContactModifierConstraintAtomClass_Members),
int(sizeof(hkSoftContactModifierConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMassChangerModifierConstraintAtomClass_Members[] =
{
{ "factorA", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "factorB", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMassChangerModifierConstraintAtomClass(
"hkMassChangerModifierConstraintAtom",
&hkModifierConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMassChangerModifierConstraintAtomClass_Members),
int(sizeof(hkMassChangerModifierConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkViscousSurfaceModifierConstraintAtomClass(
"hkViscousSurfaceModifierConstraintAtom",
&hkModifierConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkMovingSurfaceModifierConstraintAtomClass_Members[] =
{
{ "velocity", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMovingSurfaceModifierConstraintAtomClass(
"hkMovingSurfaceModifierConstraintAtom",
&hkModifierConstraintAtomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMovingSurfaceModifierConstraintAtomClass_Members),
int(sizeof(hkMovingSurfaceModifierConstraintAtomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkActionClass_Members[] =
{
{ "world", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "island", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "userData", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkActionClass(
"hkAction",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkActionClass_Members),
int(sizeof(hkActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkArrayActionClass_Members[] =
{
{ "entities", &hkEntityClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkArrayActionClass(
"hkArrayAction",
&hkActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkArrayActionClass_Members),
int(sizeof(hkArrayActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBinaryActionClass_Members[] =
{
{ "entityA", &hkEntityClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "entityB", &hkEntityClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkBinaryActionClass(
"hkBinaryAction",
&hkActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBinaryActionClass_Members),
int(sizeof(hkBinaryActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkUnaryActionClass_Members[] =
{
{ "entity", &hkEntityClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkUnaryActionClass(
"hkUnaryAction",
&hkActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkUnaryActionClass_Members),
int(sizeof(hkUnaryActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkMaterialResponseTypeEnumItems[] =
{
{0, "RESPONSE_INVALID"},
{1, "RESPONSE_SIMPLE_CONTACT"},
{2, "RESPONSE_REPORTING"},
{3, "RESPONSE_NONE"},
{4, "RESPONSE_MAX_ID"},
};
static const hkInternalClassEnum hkMaterialEnums[] = {
{"ResponseType", hkMaterialResponseTypeEnumItems, 5, HK_NULL, 0 }
};
const hkClassEnum* hkMaterialResponseTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkMaterialEnums[0]);
static hkInternalClassMember hkMaterialClass_Members[] =
{
{ "responseType", HK_NULL, hkMaterialResponseTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "friction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "restitution", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMaterialClass(
"hkMaterial",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkMaterialEnums),
1,
reinterpret_cast<const hkClassMember*>(hkMaterialClass_Members),
int(sizeof(hkMaterialClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPropertyValueClass_Members[] =
{
{ "data", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT64, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPropertyValueClass(
"hkPropertyValue",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPropertyValueClass_Members),
int(sizeof(hkPropertyValueClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPropertyClass_Members[] =
{
{ "key", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "alignmentPadding", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "value", &hkPropertyValueClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPropertyClass(
"hkProperty",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPropertyClass_Members),
int(sizeof(hkPropertyClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkConstraintDataConstraintTypeEnumItems[] =
{
{0, "CONSTRAINT_TYPE_BALLANDSOCKET"},
{1, "CONSTRAINT_TYPE_HINGE"},
{2, "CONSTRAINT_TYPE_LIMITEDHINGE"},
{3, "CONSTRAINT_TYPE_POINTTOPATH"},
{6, "CONSTRAINT_TYPE_PRISMATIC"},
{7, "CONSTRAINT_TYPE_RAGDOLL"},
{8, "CONSTRAINT_TYPE_STIFFSPRING"},
{9, "CONSTRAINT_TYPE_WHEEL"},
{10, "CONSTRAINT_TYPE_GENERIC"},
{11, "CONSTRAINT_TYPE_CONTACT"},
{12, "CONSTRAINT_TYPE_BREAKABLE"},
{13, "CONSTRAINT_TYPE_MALLEABLE"},
{14, "CONSTRAINT_TYPE_POINTTOPLANE"},
{15, "CONSTRAINT_TYPE_PULLEY"},
{18, "CONSTRAINT_TYPE_HINGE_LIMITS"},
{19, "CONSTRAINT_TYPE_RAGDOLL_LIMITS"},
{100, "BEGIN_CONSTRAINT_CHAIN_TYPES"},
{100, "CONSTRAINT_TYPE_STIFF_SPRING_CHAIN"},
{101, "CONSTRAINT_TYPE_BALL_SOCKET_CHAIN"},
{102, "CONSTRAINT_TYPE_POWERED_CHAIN"},
};
static const hkInternalClassEnum hkConstraintDataEnums[] = {
{"ConstraintType", hkConstraintDataConstraintTypeEnumItems, 20, HK_NULL, 0 }
};
const hkClassEnum* hkConstraintDataConstraintTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkConstraintDataEnums[0]);
static hkInternalClassMember hkConstraintDataClass_Members[] =
{
{ "userData", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkConstraintDataClass(
"hkConstraintData",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkConstraintDataEnums),
1,
reinterpret_cast<const hkClassMember*>(hkConstraintDataClass_Members),
int(sizeof(hkConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkConstraintInfoClass_Members[] =
{
{ "maxSizeOfJacobians", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "sizeOfJacobians", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "sizeOfSchemas", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numSolverResults", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkConstraintInfoClass(
"hkConstraintInfo",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConstraintInfoClass_Members),
int(sizeof(hkConstraintInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
extern const hkClassEnum* hkConstraintInstanceConstraintPriorityEnum;
static const hkInternalClassEnumItem hkConstraintInstanceConstraintPriorityEnumItems[] =
{
{0, "PRIORITY_INVALID"},
{1, "PRIORITY_PSI"},
{2, "PRIORITY_TOI"},
{3, "PRIORITY_TOI_HIGHER"},
{4, "PRIORITY_TOI_FORCED"},
};
static const hkInternalClassEnumItem hkConstraintInstanceInstanceTypeEnumItems[] =
{
{0, "TYPE_NORMAL"},
{1, "TYPE_CHAIN"},
};
static const hkInternalClassEnumItem hkConstraintInstanceAddReferencesEnumItems[] =
{
{0, "DO_NOT_ADD_REFERENCES"},
{1, "DO_ADD_REFERENCES"},
};
static const hkInternalClassEnum hkConstraintInstanceEnums[] = {
{"ConstraintPriority", hkConstraintInstanceConstraintPriorityEnumItems, 5, HK_NULL, 0 },
{"InstanceType", hkConstraintInstanceInstanceTypeEnumItems, 2, HK_NULL, 0 },
{"AddReferences", hkConstraintInstanceAddReferencesEnumItems, 2, HK_NULL, 0 }
};
const hkClassEnum* hkConstraintInstanceConstraintPriorityEnum = reinterpret_cast<const hkClassEnum*>(&hkConstraintInstanceEnums[0]);
const hkClassEnum* hkConstraintInstanceInstanceTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkConstraintInstanceEnums[1]);
const hkClassEnum* hkConstraintInstanceAddReferencesEnum = reinterpret_cast<const hkClassEnum*>(&hkConstraintInstanceEnums[2]);
static hkInternalClassMember hkConstraintInstanceClass_Members[] =
{
{ "owner", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "data", &hkConstraintDataClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "constraintModifiers", &hkModifierConstraintAtomClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "entities", &hkEntityClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 2, 0, 0, HK_NULL },
{ "priority", HK_NULL, hkConstraintInstanceConstraintPriorityEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "wantRuntime", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "userData", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "internal", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkConstraintInstanceClass(
"hkConstraintInstance",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkConstraintInstanceEnums),
3,
reinterpret_cast<const hkClassMember*>(hkConstraintInstanceClass_Members),
int(sizeof(hkConstraintInstanceClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBallAndSocketConstraintData_AtomsClass_Members[] =
{
{ "pivots", &hkSetLocalTranslationsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "ballSocket", &hkBallSocketConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBallAndSocketConstraintDataAtomsClass(
"hkBallAndSocketConstraintDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBallAndSocketConstraintData_AtomsClass_Members),
int(sizeof(hkBallAndSocketConstraintData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBallAndSocketConstraintDataClass_Members[] =
{
{ "atoms", &hkBallAndSocketConstraintDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBallAndSocketConstraintDataClass(
"hkBallAndSocketConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBallAndSocketConstraintDataClass_Members),
int(sizeof(hkBallAndSocketConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkHingeConstraintDataAtomsAxisEnumItems[] =
{
{0, "AXIS_AXLE"},
};
static const hkInternalClassEnum hkHingeConstraintDataAtomsEnums[] = {
{"Axis", hkHingeConstraintDataAtomsAxisEnumItems, 1, HK_NULL, 0 }
};
const hkClassEnum* hkHingeConstraintDataAtomsAxisEnum = reinterpret_cast<const hkClassEnum*>(&hkHingeConstraintDataAtomsEnums[0]);
static hkInternalClassMember hkHingeConstraintData_AtomsClass_Members[] =
{
{ "transforms", &hkSetLocalTransformsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "2dAng", &hk2dAngConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "ballSocket", &hkBallSocketConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkHingeConstraintDataAtomsClass(
"hkHingeConstraintDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkHingeConstraintDataAtomsEnums),
1,
reinterpret_cast<const hkClassMember*>(hkHingeConstraintData_AtomsClass_Members),
int(sizeof(hkHingeConstraintData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkHingeConstraintDataClass_Members[] =
{
{ "atoms", &hkHingeConstraintDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkHingeConstraintDataClass(
"hkHingeConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkHingeConstraintDataClass_Members),
int(sizeof(hkHingeConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkLimitedHingeConstraintDataAtomsAxisEnumItems[] =
{
{0, "AXIS_AXLE"},
{1, "AXIS_PERP_TO_AXLE_1"},
{2, "AXIS_PERP_TO_AXLE_2"},
};
static const hkInternalClassEnum hkLimitedHingeConstraintDataAtomsEnums[] = {
{"Axis", hkLimitedHingeConstraintDataAtomsAxisEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkLimitedHingeConstraintDataAtomsAxisEnum = reinterpret_cast<const hkClassEnum*>(&hkLimitedHingeConstraintDataAtomsEnums[0]);
static hkInternalClassMember hkLimitedHingeConstraintData_AtomsClass_Members[] =
{
{ "transforms", &hkSetLocalTransformsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angMotor", &hkAngMotorConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angFriction", &hkAngFrictionConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angLimit", &hkAngLimitConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "2dAng", &hk2dAngConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "ballSocket", &hkBallSocketConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkLimitedHingeConstraintDataAtomsClass(
"hkLimitedHingeConstraintDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkLimitedHingeConstraintDataAtomsEnums),
1,
reinterpret_cast<const hkClassMember*>(hkLimitedHingeConstraintData_AtomsClass_Members),
int(sizeof(hkLimitedHingeConstraintData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkLimitedHingeConstraintDataClass_Members[] =
{
{ "atoms", &hkLimitedHingeConstraintDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkLimitedHingeConstraintDataClass(
"hkLimitedHingeConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkLimitedHingeConstraintDataClass_Members),
int(sizeof(hkLimitedHingeConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkLinearParametricCurveClass_Members[] =
{
{ "smoothingFactor", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "closedLoop", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "dirNotParallelToTangentAlongWholePath", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "points", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_VECTOR4, 0, 0, 0, HK_NULL },
{ "distance", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
hkClass hkLinearParametricCurveClass(
"hkLinearParametricCurve",
&hkParametricCurveClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkLinearParametricCurveClass_Members),
int(sizeof(hkLinearParametricCurveClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkParametricCurveClass(
"hkParametricCurve",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static const hkInternalClassEnumItem hkPointToPathConstraintDataOrientationConstraintTypeEnumItems[] =
{
{0, "CONSTRAIN_ORIENTATION_INVALID"},
{1, "CONSTRAIN_ORIENTATION_NONE"},
{2, "CONSTRAIN_ORIENTATION_ALLOW_SPIN"},
{3, "CONSTRAIN_ORIENTATION_TO_PATH"},
{4, "CONSTRAIN_ORIENTATION_MAX_ID"},
};
static const hkInternalClassEnum hkPointToPathConstraintDataEnums[] = {
{"OrientationConstraintType", hkPointToPathConstraintDataOrientationConstraintTypeEnumItems, 5, HK_NULL, 0 }
};
const hkClassEnum* hkPointToPathConstraintDataOrientationConstraintTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkPointToPathConstraintDataEnums[0]);
static hkInternalClassMember hkPointToPathConstraintDataClass_Members[] =
{
{ "atoms", &hkBridgeAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "path", &hkParametricCurveClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "maxFrictionForce", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angularConstrainedDOF", HK_NULL, hkPointToPathConstraintDataOrientationConstraintTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "transform_OS_KS", HK_NULL, HK_NULL, hkClassMember::TYPE_TRANSFORM, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL }
};
hkClass hkPointToPathConstraintDataClass(
"hkPointToPathConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkPointToPathConstraintDataEnums),
1,
reinterpret_cast<const hkClassMember*>(hkPointToPathConstraintDataClass_Members),
int(sizeof(hkPointToPathConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPointToPlaneConstraintData_AtomsClass_Members[] =
{
{ "transforms", &hkSetLocalTransformsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lin", &hkLinConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPointToPlaneConstraintDataAtomsClass(
"hkPointToPlaneConstraintDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPointToPlaneConstraintData_AtomsClass_Members),
int(sizeof(hkPointToPlaneConstraintData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPointToPlaneConstraintDataClass_Members[] =
{
{ "atoms", &hkPointToPlaneConstraintDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPointToPlaneConstraintDataClass(
"hkPointToPlaneConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPointToPlaneConstraintDataClass_Members),
int(sizeof(hkPointToPlaneConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkPrismaticConstraintDataAtomsAxisEnumItems[] =
{
{0, "AXIS_SHAFT"},
{1, "AXIS_PERP_TO_SHAFT"},
};
static const hkInternalClassEnum hkPrismaticConstraintDataAtomsEnums[] = {
{"Axis", hkPrismaticConstraintDataAtomsAxisEnumItems, 2, HK_NULL, 0 }
};
const hkClassEnum* hkPrismaticConstraintDataAtomsAxisEnum = reinterpret_cast<const hkClassEnum*>(&hkPrismaticConstraintDataAtomsEnums[0]);
static hkInternalClassMember hkPrismaticConstraintData_AtomsClass_Members[] =
{
{ "transforms", &hkSetLocalTransformsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "motor", &hkLinMotorConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "friction", &hkLinFrictionConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "ang", &hkAngConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lin0", &hkLinConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lin1", &hkLinConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "linLimit", &hkLinLimitConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPrismaticConstraintDataAtomsClass(
"hkPrismaticConstraintDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkPrismaticConstraintDataAtomsEnums),
1,
reinterpret_cast<const hkClassMember*>(hkPrismaticConstraintData_AtomsClass_Members),
int(sizeof(hkPrismaticConstraintData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPrismaticConstraintDataClass_Members[] =
{
{ "atoms", &hkPrismaticConstraintDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPrismaticConstraintDataClass(
"hkPrismaticConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPrismaticConstraintDataClass_Members),
int(sizeof(hkPrismaticConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkStiffSpringConstraintData_AtomsClass_Members[] =
{
{ "pivots", &hkSetLocalTranslationsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "spring", &hkStiffSpringConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkStiffSpringConstraintDataAtomsClass(
"hkStiffSpringConstraintDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkStiffSpringConstraintData_AtomsClass_Members),
int(sizeof(hkStiffSpringConstraintData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkStiffSpringConstraintDataClass_Members[] =
{
{ "atoms", &hkStiffSpringConstraintDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkStiffSpringConstraintDataClass(
"hkStiffSpringConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkStiffSpringConstraintDataClass_Members),
int(sizeof(hkStiffSpringConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkWheelConstraintDataAtomsAxisEnumItems[] =
{
{0, "AXIS_SUSPENSION"},
{1, "AXIS_PERP_SUSPENSION"},
{0, "AXIS_AXLE"},
{1, "AXIS_STEERING"},
};
static const hkInternalClassEnum hkWheelConstraintDataAtomsEnums[] = {
{"Axis", hkWheelConstraintDataAtomsAxisEnumItems, 4, HK_NULL, 0 }
};
const hkClassEnum* hkWheelConstraintDataAtomsAxisEnum = reinterpret_cast<const hkClassEnum*>(&hkWheelConstraintDataAtomsEnums[0]);
static hkInternalClassMember hkWheelConstraintData_AtomsClass_Members[] =
{
{ "suspensionBase", &hkSetLocalTransformsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lin0Limit", &hkLinLimitConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lin0Soft", &hkLinSoftConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lin1", &hkLinConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lin2", &hkLinConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "steeringBase", &hkSetLocalRotationsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "2dAng", &hk2dAngConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkWheelConstraintDataAtomsClass(
"hkWheelConstraintDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkWheelConstraintDataAtomsEnums),
1,
reinterpret_cast<const hkClassMember*>(hkWheelConstraintData_AtomsClass_Members),
int(sizeof(hkWheelConstraintData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkWheelConstraintDataClass_Members[] =
{
{ "atoms", &hkWheelConstraintDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "initialAxleInB", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "initialSteeringAxisInB", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkWheelConstraintDataClass(
"hkWheelConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkWheelConstraintDataClass_Members),
int(sizeof(hkWheelConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBreakableConstraintDataClass_Members[] =
{
{ "atoms", &hkBridgeAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "constraintData", &hkConstraintDataClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "childRuntimeSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "childNumSolverResults", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "world", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "solverResultLimit", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "removeWhenBroken", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "revertBackVelocityOnBreak", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "listener", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkBreakableConstraintDataClass(
"hkBreakableConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBreakableConstraintDataClass_Members),
int(sizeof(hkBreakableConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkConstraintChainDataClass(
"hkConstraintChainData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkConstraintChainInstanceClass_Members[] =
{
{ "chainedEntities", &hkEntityClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "action", &hkConstraintChainInstanceActionClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkConstraintChainInstanceClass(
"hkConstraintChainInstance",
&hkConstraintInstanceClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConstraintChainInstanceClass_Members),
int(sizeof(hkConstraintChainInstanceClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkConstraintChainInstanceActionClass_Members[] =
{
{ "constraintInstance", &hkConstraintChainInstanceClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkConstraintChainInstanceActionClass(
"hkConstraintChainInstanceAction",
&hkActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConstraintChainInstanceActionClass_Members),
int(sizeof(hkConstraintChainInstanceActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBallSocketChainData_ConstraintInfoClass_Members[] =
{
{ "pivotInA", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "pivotInB", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBallSocketChainDataConstraintInfoClass(
"hkBallSocketChainDataConstraintInfo",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBallSocketChainData_ConstraintInfoClass_Members),
int(sizeof(hkBallSocketChainData_ConstraintInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBallSocketChainDataClass_Members[] =
{
{ "atoms", &hkBridgeAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "infos", &hkBallSocketChainDataConstraintInfoClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "tau", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "damping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "cfm", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxErrorDistance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBallSocketChainDataClass(
"hkBallSocketChainData",
&hkConstraintChainDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBallSocketChainDataClass_Members),
int(sizeof(hkBallSocketChainDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkHingeLimitsDataAtomsAxisEnumItems[] =
{
{0, "AXIS_AXLE"},
{1, "AXIS_PERP_TO_AXLE_1"},
{2, "AXIS_PERP_TO_AXLE_2"},
};
static const hkInternalClassEnum hkHingeLimitsDataAtomsEnums[] = {
{"Axis", hkHingeLimitsDataAtomsAxisEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkHingeLimitsDataAtomsAxisEnum = reinterpret_cast<const hkClassEnum*>(&hkHingeLimitsDataAtomsEnums[0]);
static hkInternalClassMember hkHingeLimitsData_AtomsClass_Members[] =
{
{ "rotations", &hkSetLocalRotationsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angLimit", &hkAngLimitConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "2dAng", &hk2dAngConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkHingeLimitsDataAtomsClass(
"hkHingeLimitsDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkHingeLimitsDataAtomsEnums),
1,
reinterpret_cast<const hkClassMember*>(hkHingeLimitsData_AtomsClass_Members),
int(sizeof(hkHingeLimitsData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkHingeLimitsDataClass_Members[] =
{
{ "atoms", &hkHingeLimitsDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkHingeLimitsDataClass(
"hkHingeLimitsData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkHingeLimitsDataClass_Members),
int(sizeof(hkHingeLimitsDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPoweredChainData_ConstraintInfoClass_Members[] =
{
{ "pivotInA", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "pivotInB", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "aTc", HK_NULL, HK_NULL, hkClassMember::TYPE_QUATERNION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "bTc", HK_NULL, HK_NULL, hkClassMember::TYPE_QUATERNION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "motors", &hkConstraintMotorClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 3, 0, 0, HK_NULL },
{ "switchBodies", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPoweredChainDataConstraintInfoClass(
"hkPoweredChainDataConstraintInfo",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPoweredChainData_ConstraintInfoClass_Members),
int(sizeof(hkPoweredChainData_ConstraintInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPoweredChainDataClass_Members[] =
{
{ "atoms", &hkBridgeAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "infos", &hkPoweredChainDataConstraintInfoClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "tau", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "damping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "cfmLinAdd", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "cfmLinMul", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "cfmAngAdd", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "cfmAngMul", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxErrorDistance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkPoweredChainData_DefaultStruct
{
int s_defaultOffsets[9];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_cfmLinAdd;
hkReal m_cfmLinMul;
hkReal m_cfmAngAdd;
hkReal m_cfmAngMul;
};
const hkPoweredChainData_DefaultStruct hkPoweredChainData_Default =
{
{-1,-1,-1,-1,HK_OFFSET_OF(hkPoweredChainData_DefaultStruct,m_cfmLinAdd),HK_OFFSET_OF(hkPoweredChainData_DefaultStruct,m_cfmLinMul),HK_OFFSET_OF(hkPoweredChainData_DefaultStruct,m_cfmAngAdd),HK_OFFSET_OF(hkPoweredChainData_DefaultStruct,m_cfmAngMul),-1},
0.1f*1.19209290e-07f,1.0f,0.1f*1.19209290e-07F,1.0f
};
}
hkClass hkPoweredChainDataClass(
"hkPoweredChainData",
&hkConstraintChainDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPoweredChainDataClass_Members),
int(sizeof(hkPoweredChainDataClass_Members)/sizeof(hkInternalClassMember)),
&hkPoweredChainData_Default
);
static hkInternalClassMember hkStiffSpringChainData_ConstraintInfoClass_Members[] =
{
{ "pivotInA", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "pivotInB", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "springLength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkStiffSpringChainDataConstraintInfoClass(
"hkStiffSpringChainDataConstraintInfo",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkStiffSpringChainData_ConstraintInfoClass_Members),
int(sizeof(hkStiffSpringChainData_ConstraintInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkStiffSpringChainDataClass_Members[] =
{
{ "atoms", &hkBridgeAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "infos", &hkStiffSpringChainDataConstraintInfoClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "tau", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "damping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "cfm", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkStiffSpringChainDataClass(
"hkStiffSpringChainData",
&hkConstraintChainDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkStiffSpringChainDataClass_Members),
int(sizeof(hkStiffSpringChainDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkGenericConstraintDataClass_Members[] =
{
{ "atoms", &hkBridgeAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "scheme", &hkGenericConstraintDataSchemeClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkGenericConstraintDataClass(
"hkGenericConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkGenericConstraintDataClass_Members),
int(sizeof(hkGenericConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkGenericConstraintDataSchemeClass_Members[] =
{
{ "info", &hkConstraintInfoClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "data", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_VECTOR4, 0, 0, 0, HK_NULL },
{ "commands", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_INT32, 0, 0, 0, HK_NULL },
{ "modifiers", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL },
{ "motors", &hkConstraintMotorClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkGenericConstraintDataSchemeClass(
"hkGenericConstraintDataScheme",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkGenericConstraintDataSchemeClass_Members),
int(sizeof(hkGenericConstraintDataSchemeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMalleableConstraintDataClass_Members[] =
{
{ "constraintData", &hkConstraintDataClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "atoms", &hkBridgeAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "strength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMalleableConstraintDataClass(
"hkMalleableConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMalleableConstraintDataClass_Members),
int(sizeof(hkMalleableConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkConstraintMotorMotorTypeEnumItems[] =
{
{0, "TYPE_INVALID"},
{1, "TYPE_POSITION"},
{2, "TYPE_VELOCITY"},
{3, "TYPE_SPRING_DAMPER"},
{4, "TYPE_MAX"},
};
static const hkInternalClassEnum hkConstraintMotorEnums[] = {
{"MotorType", hkConstraintMotorMotorTypeEnumItems, 5, HK_NULL, 0 }
};
const hkClassEnum* hkConstraintMotorMotorTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkConstraintMotorEnums[0]);
static hkInternalClassMember hkConstraintMotorClass_Members[] =
{
{ "type", HK_NULL, hkConstraintMotorMotorTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL }
};
hkClass hkConstraintMotorClass(
"hkConstraintMotor",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkConstraintMotorEnums),
1,
reinterpret_cast<const hkClassMember*>(hkConstraintMotorClass_Members),
int(sizeof(hkConstraintMotorClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkLimitedForceConstraintMotorClass_Members[] =
{
{ "minForce", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxForce", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkLimitedForceConstraintMotorClass(
"hkLimitedForceConstraintMotor",
&hkConstraintMotorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkLimitedForceConstraintMotorClass_Members),
int(sizeof(hkLimitedForceConstraintMotorClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPositionConstraintMotorClass_Members[] =
{
{ "tau", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "damping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "proportionalRecoveryVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "constantRecoveryVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPositionConstraintMotorClass(
"hkPositionConstraintMotor",
&hkLimitedForceConstraintMotorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPositionConstraintMotorClass_Members),
int(sizeof(hkPositionConstraintMotorClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSpringDamperConstraintMotorClass_Members[] =
{
{ "springConstant", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "springDamping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSpringDamperConstraintMotorClass(
"hkSpringDamperConstraintMotor",
&hkLimitedForceConstraintMotorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSpringDamperConstraintMotorClass_Members),
int(sizeof(hkSpringDamperConstraintMotorClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVelocityConstraintMotorClass_Members[] =
{
{ "tau", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "velocityTarget", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "useVelocityTargetFromConstraintTargets", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVelocityConstraintMotorClass(
"hkVelocityConstraintMotor",
&hkLimitedForceConstraintMotorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVelocityConstraintMotorClass_Members),
int(sizeof(hkVelocityConstraintMotorClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPulleyConstraintData_AtomsClass_Members[] =
{
{ "translations", &hkSetLocalTranslationsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "pulley", &hkPulleyConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPulleyConstraintDataAtomsClass(
"hkPulleyConstraintDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPulleyConstraintData_AtomsClass_Members),
int(sizeof(hkPulleyConstraintData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPulleyConstraintDataClass_Members[] =
{
{ "atoms", &hkPulleyConstraintDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPulleyConstraintDataClass(
"hkPulleyConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPulleyConstraintDataClass_Members),
int(sizeof(hkPulleyConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkEntityClass_Members[] =
{
{ "simulationIsland", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "material", &hkMaterialClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "deactivator", &hkEntityDeactivatorClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "constraintsMaster", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL },
{ "constraintsSlave", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL },
{ "constraintRuntime", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT8, 0, 0, 0, HK_NULL },
{ "storageIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "processContactCallbackDelay", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT16, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "autoRemoveLevel", HK_NULL, HK_NULL, hkClassMember::TYPE_INT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "solverData", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "uid", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "motion", &hkMaxSizeMotionClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "collisionListeners", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL },
{ "activationListeners", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL },
{ "entityListeners", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL },
{ "actions", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkEntity_DefaultStruct
{
int s_defaultOffsets[16];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkUint32 m_uid;
};
const hkEntity_DefaultStruct hkEntity_Default =
{
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkEntity_DefaultStruct,m_uid),-1,-1,-1,-1,-1},
0xffffffff
};
}
hkClass hkEntityClass(
"hkEntity",
&hkWorldObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkEntityClass_Members),
int(sizeof(hkEntityClass_Members)/sizeof(hkInternalClassMember)),
&hkEntity_Default
);
hkClass hkEntityDeactivatorClass(
"hkEntityDeactivator",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkFakeRigidBodyDeactivatorClass(
"hkFakeRigidBodyDeactivator",
&hkRigidBodyDeactivatorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkRigidBodyClass(
"hkRigidBody",
&hkEntityClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static const hkInternalClassEnumItem hkRigidBodyDeactivatorDeactivatorTypeEnumItems[] =
{
{0, "DEACTIVATOR_INVALID"},
{1, "DEACTIVATOR_NEVER"},
{2, "DEACTIVATOR_SPATIAL"},
{3, "DEACTIVATOR_MAX_ID"},
};
static const hkInternalClassEnum hkRigidBodyDeactivatorEnums[] = {
{"DeactivatorType", hkRigidBodyDeactivatorDeactivatorTypeEnumItems, 4, HK_NULL, 0 }
};
const hkClassEnum* hkRigidBodyDeactivatorDeactivatorTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkRigidBodyDeactivatorEnums[0]);
hkClass hkRigidBodyDeactivatorClass(
"hkRigidBodyDeactivator",
&hkEntityDeactivatorClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkRigidBodyDeactivatorEnums),
1,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkSpatialRigidBodyDeactivator_SampleClass_Members[] =
{
{ "refPosition", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "refRotation", HK_NULL, HK_NULL, hkClassMember::TYPE_QUATERNION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSpatialRigidBodyDeactivatorSampleClass(
"hkSpatialRigidBodyDeactivatorSample",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSpatialRigidBodyDeactivator_SampleClass_Members),
int(sizeof(hkSpatialRigidBodyDeactivator_SampleClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSpatialRigidBodyDeactivatorClass_Members[] =
{
{ "highFrequencySample", &hkSpatialRigidBodyDeactivatorSampleClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lowFrequencySample", &hkSpatialRigidBodyDeactivatorSampleClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "radiusSqrd", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "minHighFrequencyTranslation", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "minHighFrequencyRotation", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "minLowFrequencyTranslation", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "minLowFrequencyRotation", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSpatialRigidBodyDeactivatorClass(
"hkSpatialRigidBodyDeactivator",
&hkRigidBodyDeactivatorClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSpatialRigidBodyDeactivatorClass_Members),
int(sizeof(hkSpatialRigidBodyDeactivatorClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkMotionMotionTypeEnumItems[] =
{
{0, "MOTION_INVALID"},
{1, "MOTION_DYNAMIC"},
{2, "MOTION_SPHERE_INERTIA"},
{3, "MOTION_STABILIZED_SPHERE_INERTIA"},
{4, "MOTION_BOX_INERTIA"},
{5, "MOTION_STABILIZED_BOX_INERTIA"},
{6, "MOTION_KEYFRAMED"},
{7, "MOTION_FIXED"},
{8, "MOTION_THIN_BOX_INERTIA"},
{9, "MOTION_MAX_ID"},
};
static const hkInternalClassEnum hkMotionEnums[] = {
{"MotionType", hkMotionMotionTypeEnumItems, 10, HK_NULL, 0 }
};
const hkClassEnum* hkMotionMotionTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkMotionEnums[0]);
static hkInternalClassMember hkMotionClass_Members[] =
{
{ "type", HK_NULL, hkMotionMotionTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "deactivationIntegrateCounter", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "deactivationNumInactiveFrames", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT8, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "motionState", &hkMotionStateClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "inertiaAndMassInv", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "linearVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angularVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "deactivationRefPosition", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL }
};
hkClass hkMotionClass(
"hkMotion",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkMotionEnums),
1,
reinterpret_cast<const hkClassMember*>(hkMotionClass_Members),
int(sizeof(hkMotionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkBoxMotionClass(
"hkBoxMotion",
&hkMotionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkFixedRigidMotionClass(
"hkFixedRigidMotion",
&hkKeyframedRigidMotionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkKeyframedRigidMotionClass_Members[] =
{
{ "savedMotion", &hkMaxSizeMotionClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "savedQualityTypeIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkKeyframedRigidMotionClass(
"hkKeyframedRigidMotion",
&hkMotionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkKeyframedRigidMotionClass_Members),
int(sizeof(hkKeyframedRigidMotionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkMaxSizeMotionClass(
"hkMaxSizeMotion",
&hkKeyframedRigidMotionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkSphereMotionClass(
"hkSphereMotion",
&hkMotionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkStabilizedBoxMotionClass(
"hkStabilizedBoxMotion",
&hkBoxMotionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkStabilizedSphereMotionClass(
"hkStabilizedSphereMotion",
&hkSphereMotionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkThinBoxMotionClass(
"hkThinBoxMotion",
&hkBoxMotionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkAabbPhantomClass_Members[] =
{
{ "aabb", &hkAabbClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "overlappingCollidables", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL }
};
hkClass hkAabbPhantomClass(
"hkAabbPhantom",
&hkPhantomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkAabbPhantomClass_Members),
int(sizeof(hkAabbPhantomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkCachingShapePhantomClass_Members[] =
{
{ "collisionDetails", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL }
};
hkClass hkCachingShapePhantomClass(
"hkCachingShapePhantom",
&hkShapePhantomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkCachingShapePhantomClass_Members),
int(sizeof(hkCachingShapePhantomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPhantomClass_Members[] =
{
{ "overlapListeners", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL },
{ "phantomListeners", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL }
};
hkClass hkPhantomClass(
"hkPhantom",
&hkWorldObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPhantomClass_Members),
int(sizeof(hkPhantomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkShapePhantomClass_Members[] =
{
{ "motionState", &hkMotionStateClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkShapePhantomClass(
"hkShapePhantom",
&hkPhantomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkShapePhantomClass_Members),
int(sizeof(hkShapePhantomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSimpleShapePhantomClass_Members[] =
{
{ "collisionDetails", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL }
};
hkClass hkSimpleShapePhantomClass(
"hkSimpleShapePhantom",
&hkShapePhantomClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSimpleShapePhantomClass_Members),
int(sizeof(hkSimpleShapePhantomClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPhysicsSystemClass_Members[] =
{
{ "rigidBodies", &hkRigidBodyClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "constraints", &hkConstraintInstanceClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "actions", &hkActionClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "phantoms", &hkPhantomClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "userData", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "active", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkPhysicsSystem_DefaultStruct
{
int s_defaultOffsets[7];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
_hkBool m_active;
};
const hkPhysicsSystem_DefaultStruct hkPhysicsSystem_Default =
{
{-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkPhysicsSystem_DefaultStruct,m_active)},
true
};
}
hkClass hkPhysicsSystemClass(
"hkPhysicsSystem",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPhysicsSystemClass_Members),
int(sizeof(hkPhysicsSystemClass_Members)/sizeof(hkInternalClassMember)),
&hkPhysicsSystem_Default
);
static const hkInternalClassEnumItem hkWorldCinfoSolverTypeEnumItems[] =
{
{0, "SOLVER_TYPE_INVALID"},
{1, "SOLVER_TYPE_2ITERS_SOFT"},
{2, "SOLVER_TYPE_2ITERS_MEDIUM"},
{3, "SOLVER_TYPE_2ITERS_HARD"},
{4, "SOLVER_TYPE_4ITERS_SOFT"},
{5, "SOLVER_TYPE_4ITERS_MEDIUM"},
{6, "SOLVER_TYPE_4ITERS_HARD"},
{7, "SOLVER_TYPE_8ITERS_SOFT"},
{8, "SOLVER_TYPE_8ITERS_MEDIUM"},
{9, "SOLVER_TYPE_8ITERS_HARD"},
{10, "SOLVER_TYPE_MAX_ID"},
};
static const hkInternalClassEnumItem hkWorldCinfoSimulationTypeEnumItems[] =
{
{0, "SIMULATION_TYPE_INVALID"},
{1, "SIMULATION_TYPE_DISCRETE"},
{2, "SIMULATION_TYPE_CONTINUOUS"},
{3, "SIMULATION_TYPE_MULTITHREADED"},
};
static const hkInternalClassEnumItem hkWorldCinfoContactPointGenerationEnumItems[] =
{
{0, "CONTACT_POINT_ACCEPT_ALWAYS"},
{1, "CONTACT_POINT_REJECT_DUBIOUS"},
{2, "CONTACT_POINT_REJECT_MANY"},
};
static const hkInternalClassEnumItem hkWorldCinfoBroadPhaseBorderBehaviourEnumItems[] =
{
{0, "BROADPHASE_BORDER_ASSERT"},
{1, "BROADPHASE_BORDER_FIX_ENTITY"},
{2, "BROADPHASE_BORDER_REMOVE_ENTITY"},
{3, "BROADPHASE_BORDER_DO_NOTHING"},
};
static const hkInternalClassEnum hkWorldCinfoEnums[] = {
{"SolverType", hkWorldCinfoSolverTypeEnumItems, 11, HK_NULL, 0 },
{"SimulationType", hkWorldCinfoSimulationTypeEnumItems, 4, HK_NULL, 0 },
{"ContactPointGeneration", hkWorldCinfoContactPointGenerationEnumItems, 3, HK_NULL, 0 },
{"BroadPhaseBorderBehaviour", hkWorldCinfoBroadPhaseBorderBehaviourEnumItems, 4, HK_NULL, 0 }
};
const hkClassEnum* hkWorldCinfoSolverTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkWorldCinfoEnums[0]);
const hkClassEnum* hkWorldCinfoSimulationTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkWorldCinfoEnums[1]);
const hkClassEnum* hkWorldCinfoContactPointGenerationEnum = reinterpret_cast<const hkClassEnum*>(&hkWorldCinfoEnums[2]);
const hkClassEnum* hkWorldCinfoBroadPhaseBorderBehaviourEnum = reinterpret_cast<const hkClassEnum*>(&hkWorldCinfoEnums[3]);
static hkInternalClassMember hkWorldCinfoClass_Members[] =
{
{ "gravity", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "broadPhaseQuerySize", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "contactRestingVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "broadPhaseBorderBehaviour", HK_NULL, hkWorldCinfoBroadPhaseBorderBehaviourEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "broadPhaseWorldAabb", &hkAabbClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "collisionTolerance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "collisionFilter", &hkCollisionFilterClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "convexListFilter", &hkConvexListFilterClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "expectedMaxLinearVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "expectedMinPsiDeltaTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "memoryWatchDog", &hkWorldMemoryWatchDogClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "broadPhaseNumMarkers", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "contactPointGeneration", HK_NULL, hkWorldCinfoContactPointGenerationEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "solverTau", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "solverDamp", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "solverIterations", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "solverMicrosteps", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "iterativeLinearCastEarlyOutDistance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "iterativeLinearCastMaxIterations", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "highFrequencyDeactivationPeriod", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "lowFrequencyDeactivationPeriod", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "shouldActivateOnRigidBodyTransformChange", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "wantOldStyleDeactivation", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "deactivationReferenceDistance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "toiCollisionResponseRotateNormal", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "enableDeactivation", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "simulationType", HK_NULL, hkWorldCinfoSimulationTypeEnum, hkClassMember::TYPE_ENUM, hkClassMember::TYPE_VOID, 0, hkClassMember::DEPRECATED_ENUM_8, 0, HK_NULL },
{ "enableSimulationIslands", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "minDesiredIslandSize", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "processActionsInSingleThread", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "frameMarkerPsiSnap", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkWorldCinfo_DefaultStruct
{
int s_defaultOffsets[31];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
_hkVector4 m_gravity;
hkInt32 m_broadPhaseQuerySize;
hkReal m_collisionTolerance;
hkReal m_expectedMaxLinearVelocity;
hkReal m_expectedMinPsiDeltaTime;
hkReal m_solverDamp;
hkInt32 m_solverIterations;
hkInt32 m_solverMicrosteps;
hkReal m_iterativeLinearCastEarlyOutDistance;
hkInt32 m_iterativeLinearCastMaxIterations;
hkReal m_highFrequencyDeactivationPeriod;
hkReal m_lowFrequencyDeactivationPeriod;
_hkBool m_shouldActivateOnRigidBodyTransformChange;
hkReal m_deactivationReferenceDistance;
hkReal m_toiCollisionResponseRotateNormal;
_hkBool m_enableDeactivation;
_hkBool m_enableSimulationIslands;
hkUint32 m_minDesiredIslandSize;
_hkBool m_processActionsInSingleThread;
hkReal m_frameMarkerPsiSnap;
};
const hkWorldCinfo_DefaultStruct hkWorldCinfo_Default =
{
{HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_gravity),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_broadPhaseQuerySize),-1,-1,-1,HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_collisionTolerance),-1,-1,HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_expectedMaxLinearVelocity),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_expectedMinPsiDeltaTime),-1,-1,-1,-1,HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_solverDamp),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_solverIterations),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_solverMicrosteps),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_iterativeLinearCastEarlyOutDistance),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_iterativeLinearCastMaxIterations),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_highFrequencyDeactivationPeriod),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_lowFrequencyDeactivationPeriod),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_shouldActivateOnRigidBodyTransformChange),-1,HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_deactivationReferenceDistance),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_toiCollisionResponseRotateNormal),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_enableDeactivation),-1,HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_enableSimulationIslands),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_minDesiredIslandSize),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_processActionsInSingleThread),HK_OFFSET_OF(hkWorldCinfo_DefaultStruct,m_frameMarkerPsiSnap)},
{0,-9.8f,0},1024,.1f,200,1.0f/30.0f,.6f,4,1,.01f,20,.2f,10,true,0.02f,0.2f,true,true,64,true,.0001f
};
}
hkClass hkWorldCinfoClass(
"hkWorldCinfo",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkWorldCinfoEnums),
4,
reinterpret_cast<const hkClassMember*>(hkWorldCinfoClass_Members),
int(sizeof(hkWorldCinfoClass_Members)/sizeof(hkInternalClassMember)),
&hkWorldCinfo_Default
);
static const hkInternalClassEnumItem hkWorldObjectBroadPhaseTypeEnumItems[] =
{
{0, "BROAD_PHASE_INVALID"},
{1, "BROAD_PHASE_ENTITY"},
{2, "BROAD_PHASE_PHANTOM"},
{3, "BROAD_PHASE_BORDER"},
{4, "BROAD_PHASE_MAX_ID"},
};
static const hkInternalClassEnum hkWorldObjectEnums[] = {
{"BroadPhaseType", hkWorldObjectBroadPhaseTypeEnumItems, 5, HK_NULL, 0 }
};
const hkClassEnum* hkWorldObjectBroadPhaseTypeEnum = reinterpret_cast<const hkClassEnum*>(&hkWorldObjectEnums[0]);
static hkInternalClassMember hkWorldObjectClass_Members[] =
{
{ "world", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "userData", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "multithreadLock", &hkMultiThreadLockClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "collidable", &hkLinkedCollidableClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "properties", &hkPropertyClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkWorldObjectClass(
"hkWorldObject",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkWorldObjectEnums),
1,
reinterpret_cast<const hkClassMember*>(hkWorldObjectClass_Members),
int(sizeof(hkWorldObjectClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkWorldMemoryWatchDogClass_Members[] =
{
{ "memoryLimit", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkWorldMemoryWatchDogClass(
"hkWorldMemoryWatchDog",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkWorldMemoryWatchDogClass_Members),
int(sizeof(hkWorldMemoryWatchDogClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkLinkedCollidableClass_Members[] =
{
{ "collisionEntries", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_ARRAY, 0, 0, 0, HK_NULL }
};
hkClass hkLinkedCollidableClass(
"hkLinkedCollidable",
&hkCollidableClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkLinkedCollidableClass_Members),
int(sizeof(hkLinkedCollidableClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkBroadPhaseHandleClass_Members[] =
{
{ "id", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkBroadPhaseHandleClass(
"hkBroadPhaseHandle",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkBroadPhaseHandleClass_Members),
int(sizeof(hkBroadPhaseHandleClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkConvexPieceStreamDataClass_Members[] =
{
{ "convexPieceStream", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT32, 0, 0, 0, HK_NULL },
{ "convexPieceOffsets", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT32, 0, 0, 0, HK_NULL },
{ "convexPieceSingleTriangles", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT32, 0, 0, 0, HK_NULL }
};
hkClass hkConvexPieceStreamDataClass(
"hkConvexPieceStreamData",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConvexPieceStreamDataClass_Members),
int(sizeof(hkConvexPieceStreamDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMoppCode_CodeInfoClass_Members[] =
{
{ "offset", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMoppCodeCodeInfoClass(
"hkMoppCodeCodeInfo",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMoppCode_CodeInfoClass_Members),
int(sizeof(hkMoppCode_CodeInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMoppCodeClass_Members[] =
{
{ "info", &hkMoppCodeCodeInfoClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "data", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_UINT8, 0, 0, 0, HK_NULL }
};
hkClass hkMoppCodeClass(
"hkMoppCode",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMoppCodeClass_Members),
int(sizeof(hkMoppCodeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkRagdollConstraintDataMotorIndexEnumItems[] =
{
{0, "MOTOR_TWIST"},
{1, "MOTOR_PLANE"},
{2, "MOTOR_CONE"},
};
static const hkInternalClassEnum hkRagdollConstraintDataEnums[] = {
{"MotorIndex", hkRagdollConstraintDataMotorIndexEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkRagdollConstraintDataMotorIndexEnum = reinterpret_cast<const hkClassEnum*>(&hkRagdollConstraintDataEnums[0]);
static const hkInternalClassEnumItem hkRagdollConstraintDataAtomsAxisEnumItems[] =
{
{0, "AXIS_TWIST"},
{1, "AXIS_PLANES"},
{2, "AXIS_CROSS_PRODUCT"},
};
static const hkInternalClassEnum hkRagdollConstraintDataAtomsEnums[] = {
{"Axis", hkRagdollConstraintDataAtomsAxisEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkRagdollConstraintDataAtomsAxisEnum = reinterpret_cast<const hkClassEnum*>(&hkRagdollConstraintDataAtomsEnums[0]);
static hkInternalClassMember hkRagdollConstraintData_AtomsClass_Members[] =
{
{ "transforms", &hkSetLocalTransformsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "ragdollMotors", &hkRagdollMotorConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "angFriction", &hkAngFrictionConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "twistLimit", &hkTwistLimitConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "coneLimit", &hkConeLimitConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "planesLimit", &hkConeLimitConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "ballSocket", &hkBallSocketConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkRagdollConstraintDataAtomsClass(
"hkRagdollConstraintDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkRagdollConstraintDataAtomsEnums),
1,
reinterpret_cast<const hkClassMember*>(hkRagdollConstraintData_AtomsClass_Members),
int(sizeof(hkRagdollConstraintData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkRagdollConstraintDataClass_Members[] =
{
{ "atoms", &hkRagdollConstraintDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkRagdollConstraintDataClass(
"hkRagdollConstraintData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkRagdollConstraintDataEnums),
1,
reinterpret_cast<const hkClassMember*>(hkRagdollConstraintDataClass_Members),
int(sizeof(hkRagdollConstraintDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static const hkInternalClassEnumItem hkRagdollLimitsDataAtomsAxisEnumItems[] =
{
{0, "AXIS_TWIST"},
{1, "AXIS_PLANES"},
{2, "AXIS_CROSS_PRODUCT"},
};
static const hkInternalClassEnum hkRagdollLimitsDataAtomsEnums[] = {
{"Axis", hkRagdollLimitsDataAtomsAxisEnumItems, 3, HK_NULL, 0 }
};
const hkClassEnum* hkRagdollLimitsDataAtomsAxisEnum = reinterpret_cast<const hkClassEnum*>(&hkRagdollLimitsDataAtomsEnums[0]);
static hkInternalClassMember hkRagdollLimitsData_AtomsClass_Members[] =
{
{ "rotations", &hkSetLocalRotationsConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "twistLimit", &hkTwistLimitConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "coneLimit", &hkConeLimitConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "planesLimit", &hkConeLimitConstraintAtomClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkRagdollLimitsDataAtomsClass(
"hkRagdollLimitsDataAtoms",
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassEnum*>(hkRagdollLimitsDataAtomsEnums),
1,
reinterpret_cast<const hkClassMember*>(hkRagdollLimitsData_AtomsClass_Members),
int(sizeof(hkRagdollLimitsData_AtomsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkRagdollLimitsDataClass_Members[] =
{
{ "atoms", &hkRagdollLimitsDataAtomsClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkRagdollLimitsDataClass(
"hkRagdollLimitsData",
&hkConstraintDataClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkRagdollLimitsDataClass_Members),
int(sizeof(hkRagdollLimitsDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkAngularDashpotActionClass_Members[] =
{
{ "rotation", HK_NULL, HK_NULL, hkClassMember::TYPE_QUATERNION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "strength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "damping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkAngularDashpotActionClass(
"hkAngularDashpotAction",
&hkBinaryActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkAngularDashpotActionClass_Members),
int(sizeof(hkAngularDashpotActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkDashpotActionClass_Members[] =
{
{ "point", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL },
{ "strength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "damping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "impulse", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkDashpotActionClass(
"hkDashpotAction",
&hkBinaryActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkDashpotActionClass_Members),
int(sizeof(hkDashpotActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMotorActionClass_Members[] =
{
{ "axis", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "spinRate", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "gain", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "active", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMotorActionClass(
"hkMotorAction",
&hkUnaryActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMotorActionClass_Members),
int(sizeof(hkMotorActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkReorientActionClass_Members[] =
{
{ "rotationAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "upAxis", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "strength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "damping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkReorientActionClass(
"hkReorientAction",
&hkUnaryActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkReorientActionClass_Members),
int(sizeof(hkReorientActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSpringActionClass_Members[] =
{
{ "lastForce", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "positionAinA", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "positionBinB", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "restLength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "strength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "damping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "onCompression", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "onExtension", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSpringActionClass(
"hkSpringAction",
&hkBinaryActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSpringActionClass_Members),
int(sizeof(hkSpringActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkCharacterProxyCinfoClass_Members[] =
{
{ "position", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "velocity", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "dynamicFriction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "staticFriction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "keepContactTolerance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "up", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "extraUpStaticFriction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "extraDownStaticFriction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "shapePhantom", &hkShapePhantomClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "keepDistance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "contactAngleSensitivity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "userPlanes", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxCharacterSpeedForSolver", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "characterStrength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "characterMass", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxSlope", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "penetrationRecoverySpeed", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxCastIterations", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "refreshManifoldInCheckSupport", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
namespace
{
struct hkCharacterProxyCinfo_DefaultStruct
{
int s_defaultOffsets[19];
typedef hkInt8 _hkBool;
typedef hkReal _hkVector4[4];
typedef hkReal _hkQuaternion[4];
typedef hkReal _hkMatrix3[12];
typedef hkReal _hkRotation[12];
typedef hkReal _hkQsTransform[12];
typedef hkReal _hkMatrix4[16];
typedef hkReal _hkTransform[16];
hkReal m_contactAngleSensitivity;
int m_maxCastIterations;
bool m_refreshManifoldInCheckSupport;
};
const hkCharacterProxyCinfo_DefaultStruct hkCharacterProxyCinfo_Default =
{
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkCharacterProxyCinfo_DefaultStruct,m_contactAngleSensitivity),-1,-1,-1,-1,-1,-1,HK_OFFSET_OF(hkCharacterProxyCinfo_DefaultStruct,m_maxCastIterations),HK_OFFSET_OF(hkCharacterProxyCinfo_DefaultStruct,m_refreshManifoldInCheckSupport)},
10,10,false
};
}
hkClass hkCharacterProxyCinfoClass(
"hkCharacterProxyCinfo",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkCharacterProxyCinfoClass_Members),
int(sizeof(hkCharacterProxyCinfoClass_Members)/sizeof(hkInternalClassMember)),
&hkCharacterProxyCinfo_Default
);
static hkInternalClassMember hkConstrainedSystemFilterClass_Members[] =
{
{ "otherFilter", &hkCollisionFilterClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkConstrainedSystemFilterClass(
"hkConstrainedSystemFilter",
&hkCollisionFilterClass,
0,
HK_NULL,
1,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkConstrainedSystemFilterClass_Members),
int(sizeof(hkConstrainedSystemFilterClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkDisableEntityCollisionFilterClass_Members[] =
{
{ "disabledEntities", &hkEntityClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkDisableEntityCollisionFilterClass(
"hkDisableEntityCollisionFilter",
&hkCollisionFilterClass,
0,
HK_NULL,
1,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkDisableEntityCollisionFilterClass_Members),
int(sizeof(hkDisableEntityCollisionFilterClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkGroupCollisionFilterClass_Members[] =
{
{ "noGroupCollisionEnabled", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "collisionGroups", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 32, 0, 0, HK_NULL }
};
hkClass hkGroupCollisionFilterClass(
"hkGroupCollisionFilter",
&hkCollisionFilterClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkGroupCollisionFilterClass_Members),
int(sizeof(hkGroupCollisionFilterClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPairwiseCollisionFilter_CollisionPairClass_Members[] =
{
{ "a", &hkEntityClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "b", &hkEntityClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkPairwiseCollisionFilterCollisionPairClass(
"hkPairwiseCollisionFilterCollisionPair",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPairwiseCollisionFilter_CollisionPairClass_Members),
int(sizeof(hkPairwiseCollisionFilter_CollisionPairClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPairwiseCollisionFilterClass_Members[] =
{
{ "disabledPairs", &hkPairwiseCollisionFilterCollisionPairClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkPairwiseCollisionFilterClass(
"hkPairwiseCollisionFilter",
&hkCollisionFilterClass,
0,
HK_NULL,
1,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPairwiseCollisionFilterClass_Members),
int(sizeof(hkPairwiseCollisionFilterClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPoweredChainMapper_TargetClass_Members[] =
{
{ "chain", &hkPoweredChainDataClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "infoIndex", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkPoweredChainMapperTargetClass(
"hkPoweredChainMapperTarget",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPoweredChainMapper_TargetClass_Members),
int(sizeof(hkPoweredChainMapper_TargetClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPoweredChainMapper_LinkInfoClass_Members[] =
{
{ "firstTargetIdx", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numTargets", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "limitConstraint", &hkConstraintInstanceClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkPoweredChainMapperLinkInfoClass(
"hkPoweredChainMapperLinkInfo",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPoweredChainMapper_LinkInfoClass_Members),
int(sizeof(hkPoweredChainMapper_LinkInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPoweredChainMapperClass_Members[] =
{
{ "links", &hkPoweredChainMapperLinkInfoClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "targets", &hkPoweredChainMapperTargetClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "chains", &hkConstraintChainInstanceClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkPoweredChainMapperClass(
"hkPoweredChainMapper",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPoweredChainMapperClass_Members),
int(sizeof(hkPoweredChainMapperClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkMouseSpringActionClass_Members[] =
{
{ "positionInRbLocal", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "mousePositionInWorld", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "springDamping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "springElasticity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxRelativeForce", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "objectDamping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkMouseSpringActionClass(
"hkMouseSpringAction",
&hkUnaryActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkMouseSpringActionClass_Members),
int(sizeof(hkMouseSpringActionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkRigidBodyDisplayBindingClass_Members[] =
{
{ "rigidBody", &hkRigidBodyClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "displayObject", &hkxMeshClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "rigidBodyFromDisplayObjectTransform", HK_NULL, HK_NULL, hkClassMember::TYPE_MATRIX4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkRigidBodyDisplayBindingClass(
"hkRigidBodyDisplayBinding",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkRigidBodyDisplayBindingClass_Members),
int(sizeof(hkRigidBodyDisplayBindingClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPhysicsSystemDisplayBindingClass_Members[] =
{
{ "bindings", &hkRigidBodyDisplayBindingClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "system", &hkPhysicsSystemClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkPhysicsSystemDisplayBindingClass(
"hkPhysicsSystemDisplayBinding",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPhysicsSystemDisplayBindingClass_Members),
int(sizeof(hkPhysicsSystemDisplayBindingClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkDisplayBindingDataClass_Members[] =
{
{ "rigidBodyBindings", &hkRigidBodyDisplayBindingClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "physicsSystemBindings", &hkPhysicsSystemDisplayBindingClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkDisplayBindingDataClass(
"hkDisplayBindingData",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkDisplayBindingDataClass_Members),
int(sizeof(hkDisplayBindingDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkPhysicsDataClass_Members[] =
{
{ "worldCinfo", &hkWorldCinfoClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "systems", &hkPhysicsSystemClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkPhysicsDataClass(
"hkPhysicsData",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkPhysicsDataClass_Members),
int(sizeof(hkPhysicsDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSerializedDisplayMarkerClass_Members[] =
{
{ "transform", HK_NULL, HK_NULL, hkClassMember::TYPE_TRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSerializedDisplayMarkerClass(
"hkSerializedDisplayMarker",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSerializedDisplayMarkerClass_Members),
int(sizeof(hkSerializedDisplayMarkerClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSerializedDisplayMarkerListClass_Members[] =
{
{ "markers", &hkSerializedDisplayMarkerClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkSerializedDisplayMarkerListClass(
"hkSerializedDisplayMarkerList",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSerializedDisplayMarkerListClass_Members),
int(sizeof(hkSerializedDisplayMarkerListClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSerializedDisplayRbTransforms_DisplayTransformPairClass_Members[] =
{
{ "rb", &hkRigidBodyClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "localToDisplay", HK_NULL, HK_NULL, hkClassMember::TYPE_TRANSFORM, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkSerializedDisplayRbTransformsDisplayTransformPairClass(
"hkSerializedDisplayRbTransformsDisplayTransformPair",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSerializedDisplayRbTransforms_DisplayTransformPairClass_Members),
int(sizeof(hkSerializedDisplayRbTransforms_DisplayTransformPairClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkSerializedDisplayRbTransformsClass_Members[] =
{
{ "transforms", &hkSerializedDisplayRbTransformsDisplayTransformPairClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkSerializedDisplayRbTransformsClass(
"hkSerializedDisplayRbTransforms",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkSerializedDisplayRbTransformsClass_Members),
int(sizeof(hkSerializedDisplayRbTransformsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleData_WheelComponentParamsClass_Members[] =
{
{ "radius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "mass", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "width", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "friction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "viscosityFriction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxFriction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "slipAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "forceFeedbackMultiplier", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxContactBodyAcceleration", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "axle", HK_NULL, HK_NULL, hkClassMember::TYPE_INT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDataWheelComponentParamsClass(
"hkVehicleDataWheelComponentParams",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleData_WheelComponentParamsClass_Members),
int(sizeof(hkVehicleData_WheelComponentParamsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleDataClass_Members[] =
{
{ "gravity", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numWheels", HK_NULL, HK_NULL, hkClassMember::TYPE_INT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "chassisOrientation", HK_NULL, HK_NULL, hkClassMember::TYPE_ROTATION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "torqueRollFactor", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "torquePitchFactor", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "torqueYawFactor", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "extraTorqueFactor", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxVelocityForPositionalFriction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "chassisUnitInertiaYaw", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "chassisUnitInertiaRoll", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "chassisUnitInertiaPitch", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "frictionEqualizer", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "normalClippingAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "wheelParams", &hkVehicleDataWheelComponentParamsClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "numWheelsPerAxle", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_INT8, 0, 0, 0, HK_NULL },
{ "frictionDescription", &hkVehicleFrictionDescriptionClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "chassisFrictionInertiaInvDiag", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "alreadyInitialised", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDataClass(
"hkVehicleData",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDataClass_Members),
int(sizeof(hkVehicleDataClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleInstance_WheelInfoClass_Members[] =
{
{ "contactPoint", &hkContactPointClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "contactFriction", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "contactBody", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL },
{ "contactShapeKey", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "hardPointWs", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "rayEndPointWs", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "currentSuspensionLength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "suspensionDirectionWs", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "spinAxisCs", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "spinAxisWs", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "steeringOrientationCs", HK_NULL, HK_NULL, hkClassMember::TYPE_QUATERNION, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "spinVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "spinAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "skidEnergyDensity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "sideForce", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "forwardSlipVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "sideSlipVelocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleInstanceWheelInfoClass(
"hkVehicleInstanceWheelInfo",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleInstance_WheelInfoClass_Members),
int(sizeof(hkVehicleInstance_WheelInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleInstanceClass_Members[] =
{
{ "data", &hkVehicleDataClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "driverInput", &hkVehicleDriverInputClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "steering", &hkVehicleSteeringClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "engine", &hkVehicleEngineClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "transmission", &hkVehicleTransmissionClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "brake", &hkVehicleBrakeClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "suspension", &hkVehicleSuspensionClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "aerodynamics", &hkVehicleAerodynamicsClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "wheelCollide", &hkVehicleWheelCollideClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "tyreMarks", &hkTyremarksInfoClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "velocityDamper", &hkVehicleVelocityDamperClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "wheelsInfo", &hkVehicleInstanceWheelInfoClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "frictionStatus", &hkVehicleFrictionStatusClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "deviceStatus", &hkVehicleDriverInputStatusClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "isFixed", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL },
{ "wheelsTimeSinceMaxPedalInput", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tryingToReverse", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "torque", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "rpm", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "mainSteeringAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "wheelsSteeringAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "isReversing", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "currentGear", HK_NULL, HK_NULL, hkClassMember::TYPE_INT8, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "delayed", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "clutchDelayCountdown", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleInstanceClass(
"hkVehicleInstance",
&hkUnaryActionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleInstanceClass_Members),
int(sizeof(hkVehicleInstanceClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkVehicleAerodynamicsClass(
"hkVehicleAerodynamics",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkVehicleDefaultAerodynamicsClass_Members[] =
{
{ "airDensity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "frontalArea", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "dragCoefficient", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "liftCoefficient", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "extraGravityws", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDefaultAerodynamicsClass(
"hkVehicleDefaultAerodynamics",
&hkVehicleAerodynamicsClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDefaultAerodynamicsClass_Members),
int(sizeof(hkVehicleDefaultAerodynamicsClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkVehicleBrakeClass(
"hkVehicleBrake",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkVehicleDefaultBrake_WheelBrakingPropertiesClass_Members[] =
{
{ "maxBreakingTorque", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "minPedalInputToBlock", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "isConnectedToHandbrake", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDefaultBrakeWheelBrakingPropertiesClass(
"hkVehicleDefaultBrakeWheelBrakingProperties",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDefaultBrake_WheelBrakingPropertiesClass_Members),
int(sizeof(hkVehicleDefaultBrake_WheelBrakingPropertiesClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleDefaultBrakeClass_Members[] =
{
{ "wheelBrakingProperties", &hkVehicleDefaultBrakeWheelBrakingPropertiesClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "wheelsMinTimeToBlock", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDefaultBrakeClass(
"hkVehicleDefaultBrake",
&hkVehicleBrakeClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDefaultBrakeClass_Members),
int(sizeof(hkVehicleDefaultBrakeClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkVehicleDriverInputStatusClass(
"hkVehicleDriverInputStatus",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
hkClass hkVehicleDriverInputClass(
"hkVehicleDriverInput",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkVehicleDriverInputAnalogStatusClass_Members[] =
{
{ "positionX", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "positionY", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "handbrakeButtonPressed", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "reverseButtonPressed", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDriverInputAnalogStatusClass(
"hkVehicleDriverInputAnalogStatus",
&hkVehicleDriverInputStatusClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDriverInputAnalogStatusClass_Members),
int(sizeof(hkVehicleDriverInputAnalogStatusClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleDefaultAnalogDriverInputClass_Members[] =
{
{ "slopeChangePointX", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "initialSlope", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "deadZone", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "autoReverse", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDefaultAnalogDriverInputClass(
"hkVehicleDefaultAnalogDriverInput",
&hkVehicleDriverInputClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDefaultAnalogDriverInputClass_Members),
int(sizeof(hkVehicleDefaultAnalogDriverInputClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkVehicleEngineClass(
"hkVehicleEngine",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkVehicleDefaultEngineClass_Members[] =
{
{ "minRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "optRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxTorque", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "torqueFactorAtMinRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "torqueFactorAtMaxRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "resistanceFactorAtMinRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "resistanceFactorAtOptRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "resistanceFactorAtMaxRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "clutchSlipRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDefaultEngineClass(
"hkVehicleDefaultEngine",
&hkVehicleEngineClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDefaultEngineClass_Members),
int(sizeof(hkVehicleDefaultEngineClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleFrictionDescription_AxisDescriptionClass_Members[] =
{
{ "frictionCircleYtab", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 16, 0, 0, HK_NULL },
{ "xStep", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "xStart", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "wheelSurfaceInertia", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "wheelSurfaceInertiaInv", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "wheelChassisMassRatio", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "wheelRadius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "wheelRadiusInv", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "wheelDownForceFactor", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "wheelDownForceSumFactor", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleFrictionDescriptionAxisDescriptionClass(
"hkVehicleFrictionDescriptionAxisDescription",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleFrictionDescription_AxisDescriptionClass_Members),
int(sizeof(hkVehicleFrictionDescription_AxisDescriptionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleFrictionDescriptionClass_Members[] =
{
{ "wheelDistance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "chassisMassInv", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "axleDescr", &hkVehicleFrictionDescriptionAxisDescriptionClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL }
};
hkClass hkVehicleFrictionDescriptionClass(
"hkVehicleFrictionDescription",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleFrictionDescriptionClass_Members),
int(sizeof(hkVehicleFrictionDescriptionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleFrictionStatus_AxisStatusClass_Members[] =
{
{ "forward_slip_velocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "side_slip_velocity", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "skid_energy_density", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "side_force", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "delayed_forward_impulse", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "sideRhs", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "forwardRhs", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "relativeSideForce", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "relativeForwardForce", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleFrictionStatusAxisStatusClass(
"hkVehicleFrictionStatusAxisStatus",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleFrictionStatus_AxisStatusClass_Members),
int(sizeof(hkVehicleFrictionStatus_AxisStatusClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleFrictionStatusClass_Members[] =
{
{ "axis", &hkVehicleFrictionStatusAxisStatusClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 2, 0, 0, HK_NULL }
};
hkClass hkVehicleFrictionStatusClass(
"hkVehicleFrictionStatus",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleFrictionStatusClass_Members),
int(sizeof(hkVehicleFrictionStatusClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkVehicleSteeringClass(
"hkVehicleSteering",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkVehicleDefaultSteeringClass_Members[] =
{
{ "maxSteeringAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxSpeedFullSteeringAngle", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "doesWheelSteer", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_BOOL, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDefaultSteeringClass(
"hkVehicleDefaultSteering",
&hkVehicleSteeringClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDefaultSteeringClass_Members),
int(sizeof(hkVehicleDefaultSteeringClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleSuspension_SuspensionWheelParametersClass_Members[] =
{
{ "hardpointCs", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "directionCs", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "length", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleSuspensionSuspensionWheelParametersClass(
"hkVehicleSuspensionSuspensionWheelParameters",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleSuspension_SuspensionWheelParametersClass_Members),
int(sizeof(hkVehicleSuspension_SuspensionWheelParametersClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleSuspensionClass_Members[] =
{
{ "wheelParams", &hkVehicleSuspensionSuspensionWheelParametersClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleSuspensionClass(
"hkVehicleSuspension",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleSuspensionClass_Members),
int(sizeof(hkVehicleSuspensionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleDefaultSuspension_WheelSpringSuspensionParametersClass_Members[] =
{
{ "strength", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "dampingCompression", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "dampingRelaxation", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDefaultSuspensionWheelSpringSuspensionParametersClass(
"hkVehicleDefaultSuspensionWheelSpringSuspensionParameters",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDefaultSuspension_WheelSpringSuspensionParametersClass_Members),
int(sizeof(hkVehicleDefaultSuspension_WheelSpringSuspensionParametersClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleDefaultSuspensionClass_Members[] =
{
{ "wheelSpringParams", &hkVehicleDefaultSuspensionWheelSpringSuspensionParametersClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDefaultSuspensionClass(
"hkVehicleDefaultSuspension",
&hkVehicleSuspensionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDefaultSuspensionClass_Members),
int(sizeof(hkVehicleDefaultSuspensionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkVehicleTransmissionClass(
"hkVehicleTransmission",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkVehicleDefaultTransmissionClass_Members[] =
{
{ "downshiftRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "upshiftRPM", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "primaryTransmissionRatio", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "clutchDelayTime", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "reverseGearRatio", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "gearsRatio", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL },
{ "wheelsTorqueRatio", HK_NULL, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_REAL, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDefaultTransmissionClass(
"hkVehicleDefaultTransmission",
&hkVehicleTransmissionClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDefaultTransmissionClass_Members),
int(sizeof(hkVehicleDefaultTransmissionClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkTyremarkPointClass_Members[] =
{
{ "pointLeft", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "pointRight", HK_NULL, HK_NULL, hkClassMember::TYPE_VECTOR4, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkTyremarkPointClass(
"hkTyremarkPoint",
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkTyremarkPointClass_Members),
int(sizeof(hkTyremarkPointClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkTyremarksWheelClass_Members[] =
{
{ "currentPosition", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "numPoints", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tyremarkPoints", &hkTyremarkPointClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL }
};
hkClass hkTyremarksWheelClass(
"hkTyremarksWheel",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkTyremarksWheelClass_Members),
int(sizeof(hkTyremarksWheelClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkTyremarksInfoClass_Members[] =
{
{ "minTyremarkEnergy", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "maxTyremarkEnergy", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "tyremarksWheel", &hkTyremarksWheelClass, HK_NULL, hkClassMember::TYPE_ARRAY, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkTyremarksInfoClass(
"hkTyremarksInfo",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkTyremarksInfoClass_Members),
int(sizeof(hkTyremarksInfoClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
hkClass hkVehicleVelocityDamperClass(
"hkVehicleVelocityDamper",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL,
0,
HK_NULL
);
static hkInternalClassMember hkVehicleDefaultVelocityDamperClass_Members[] =
{
{ "normalSpinDamping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "collisionSpinDamping", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "collisionThreshold", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleDefaultVelocityDamperClass(
"hkVehicleDefaultVelocityDamper",
&hkVehicleVelocityDamperClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleDefaultVelocityDamperClass_Members),
int(sizeof(hkVehicleDefaultVelocityDamperClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleWheelCollideClass_Members[] =
{
{ "alreadyUsed", HK_NULL, HK_NULL, hkClassMember::TYPE_BOOL, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleWheelCollideClass(
"hkVehicleWheelCollide",
&hkReferencedObjectClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleWheelCollideClass_Members),
int(sizeof(hkVehicleWheelCollideClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkRejectRayChassisListenerClass_Members[] =
{
{ "chassis", HK_NULL, HK_NULL, hkClassMember::TYPE_ZERO, hkClassMember::TYPE_POINTER, 0, 0, 0, HK_NULL }
};
hkClass hkRejectRayChassisListenerClass(
"hkRejectRayChassisListener",
&hkReferencedObjectClass,
0,
HK_NULL,
1,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkRejectRayChassisListenerClass_Members),
int(sizeof(hkRejectRayChassisListenerClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkInternalClassMember hkVehicleRaycastWheelCollideClass_Members[] =
{
{ "wheelCollisionFilterInfo", HK_NULL, HK_NULL, hkClassMember::TYPE_UINT32, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL },
{ "phantom", &hkAabbPhantomClass, HK_NULL, hkClassMember::TYPE_POINTER, hkClassMember::TYPE_STRUCT, 0, 0, 0, HK_NULL },
{ "rejectRayChassisListener", &hkRejectRayChassisListenerClass, HK_NULL, hkClassMember::TYPE_STRUCT, hkClassMember::TYPE_VOID, 0, 0, 0, HK_NULL }
};
hkClass hkVehicleRaycastWheelCollideClass(
"hkVehicleRaycastWheelCollide",
&hkVehicleWheelCollideClass,
0,
HK_NULL,
0,
HK_NULL,
0,
reinterpret_cast<const hkClassMember*>(hkVehicleRaycastWheelCollideClass_Members),
int(sizeof(hkVehicleRaycastWheelCollideClass_Members)/sizeof(hkInternalClassMember)),
HK_NULL
);
static hkClass* const Classes[] =
{
&hk2dAngConstraintAtomClass,
&hkAabbClass,
&hkAabbPhantomClass,
&hkActionClass,
&hkAngConstraintAtomClass,
&hkAngFrictionConstraintAtomClass,
&hkAngLimitConstraintAtomClass,
&hkAngMotorConstraintAtomClass,
&hkAngularDashpotActionClass,
&hkAnimatedReferenceFrameClass,
&hkAnimationBindingClass,
&hkAnimationContainerClass,
&hkAnnotationTrackAnnotationClass,
&hkAnnotationTrackClass,
&hkArrayActionClass,
&hkBallAndSocketConstraintDataAtomsClass,
&hkBallAndSocketConstraintDataClass,
&hkBallSocketChainDataClass,
&hkBallSocketChainDataConstraintInfoClass,
&hkBallSocketConstraintAtomClass,
&hkBaseObjectClass,
&hkBinaryActionClass,
&hkBitFieldClass,
&hkBoneAttachmentClass,
&hkBoneClass,
&hkBoxMotionClass,
&hkBoxShapeClass,
&hkBreakableConstraintDataClass,
&hkBridgeAtomsClass,
&hkBridgeConstraintAtomClass,
&hkBroadPhaseHandleClass,
&hkBvShapeClass,
&hkBvTreeShapeClass,
&hkCachingShapePhantomClass,
&hkCapsuleShapeClass,
&hkCdBodyClass,
&hkCharacterProxyCinfoClass,
&hkClassClass,
&hkClassEnumClass,
&hkClassEnumItemClass,
&hkClassMemberClass,
&hkCollidableClass,
&hkCollidableCollidableFilterClass,
&hkCollisionFilterClass,
&hkCollisionFilterListClass,
&hkConeLimitConstraintAtomClass,
&hkConstrainedSystemFilterClass,
&hkConstraintAtomClass,
&hkConstraintChainDataClass,
&hkConstraintChainInstanceActionClass,
&hkConstraintChainInstanceClass,
&hkConstraintDataClass,
&hkConstraintInfoClass,
&hkConstraintInstanceClass,
&hkConstraintMotorClass,
&hkContactPointClass,
&hkContactPointMaterialClass,
&hkConvexListFilterClass,
&hkConvexListShapeClass,
&hkConvexPieceMeshShapeClass,
&hkConvexPieceStreamDataClass,
&hkConvexShapeClass,
&hkConvexTransformShapeClass,
&hkConvexTranslateShapeClass,
&hkConvexVerticesShapeClass,
&hkConvexVerticesShapeFourVectorsClass,
&hkCylinderShapeClass,
&hkDashpotActionClass,
&hkDefaultAnimatedReferenceFrameClass,
&hkDefaultConvexListFilterClass,
&hkDeltaCompressedSkeletalAnimationClass,
&hkDeltaCompressedSkeletalAnimationQuantizationFormatClass,
&hkDisableEntityCollisionFilterClass,
&hkDisplayBindingDataClass,
&hkEntityClass,
&hkEntityDeactivatorClass,
&hkExtendedMeshShapeClass,
&hkExtendedMeshShapeShapesSubpartClass,
&hkExtendedMeshShapeSubpartClass,
&hkExtendedMeshShapeTrianglesSubpartClass,
&hkFakeRigidBodyDeactivatorClass,
&hkFastMeshShapeClass,
&hkFixedRigidMotionClass,
&hkGenericConstraintDataClass,
&hkGenericConstraintDataSchemeClass,
&hkGroupCollisionFilterClass,
&hkGroupFilterClass,
&hkHeightFieldShapeClass,
&hkHingeConstraintDataAtomsClass,
&hkHingeConstraintDataClass,
&hkHingeLimitsDataAtomsClass,
&hkHingeLimitsDataClass,
&hkInterleavedSkeletalAnimationClass,
&hkKeyframedRigidMotionClass,
&hkLimitedForceConstraintMotorClass,
&hkLimitedHingeConstraintDataAtomsClass,
&hkLimitedHingeConstraintDataClass,
&hkLinConstraintAtomClass,
&hkLinFrictionConstraintAtomClass,
&hkLinLimitConstraintAtomClass,
&hkLinMotorConstraintAtomClass,
&hkLinSoftConstraintAtomClass,
&hkLinearParametricCurveClass,
&hkLinkedCollidableClass,
&hkListShapeChildInfoClass,
&hkListShapeClass,
&hkMalleableConstraintDataClass,
&hkMassChangerModifierConstraintAtomClass,
&hkMaterialClass,
&hkMaxSizeMotionClass,
&hkMeshBindingClass,
&hkMeshBindingMappingClass,
&hkMeshMaterialClass,
&hkMeshShapeClass,
&hkMeshShapeSubpartClass,
&hkModifierConstraintAtomClass,
&hkMonitorStreamFrameInfoClass,
&hkMonitorStreamStringMapClass,
&hkMonitorStreamStringMapStringMapClass,
&hkMoppBvTreeShapeClass,
&hkMoppCodeClass,
&hkMoppCodeCodeInfoClass,
&hkMotionClass,
&hkMotionStateClass,
&hkMotorActionClass,
&hkMouseSpringActionClass,
&hkMovingSurfaceModifierConstraintAtomClass,
&hkMultiRayShapeClass,
&hkMultiRayShapeRayClass,
&hkMultiSphereShapeClass,
&hkMultiThreadLockClass,
&hkNullCollisionFilterClass,
&hkOverwritePivotConstraintAtomClass,
&hkPackfileHeaderClass,
&hkPackfileSectionHeaderClass,
&hkPairwiseCollisionFilterClass,
&hkPairwiseCollisionFilterCollisionPairClass,
&hkParametricCurveClass,
&hkPhantomCallbackShapeClass,
&hkPhantomClass,
&hkPhysicsDataClass,
&hkPhysicsSystemClass,
&hkPhysicsSystemDisplayBindingClass,
&hkPlaneShapeClass,
&hkPointToPathConstraintDataClass,
&hkPointToPlaneConstraintDataAtomsClass,
&hkPointToPlaneConstraintDataClass,
&hkPositionConstraintMotorClass,
&hkPoweredChainDataClass,
&hkPoweredChainDataConstraintInfoClass,
&hkPoweredChainMapperClass,
&hkPoweredChainMapperLinkInfoClass,
&hkPoweredChainMapperTargetClass,
&hkPrismaticConstraintDataAtomsClass,
&hkPrismaticConstraintDataClass,
&hkPropertyClass,
&hkPropertyValueClass,
&hkPulleyConstraintAtomClass,
&hkPulleyConstraintDataAtomsClass,
&hkPulleyConstraintDataClass,
&hkRagdollConstraintDataAtomsClass,
&hkRagdollConstraintDataClass,
&hkRagdollInstanceClass,
&hkRagdollLimitsDataAtomsClass,
&hkRagdollLimitsDataClass,
&hkRagdollMotorConstraintAtomClass,
&hkRayCollidableFilterClass,
&hkRayShapeCollectionFilterClass,
&hkReferencedObjectClass,
&hkRejectRayChassisListenerClass,
&hkReorientActionClass,
&hkRigidBodyClass,
&hkRigidBodyDeactivatorClass,
&hkRigidBodyDisplayBindingClass,
&hkRootLevelContainerClass,
&hkRootLevelContainerNamedVariantClass,
&hkSampledHeightFieldShapeClass,
&hkSerializedDisplayMarkerClass,
&hkSerializedDisplayMarkerListClass,
&hkSerializedDisplayRbTransformsClass,
&hkSerializedDisplayRbTransformsDisplayTransformPairClass,
&hkSetLocalRotationsConstraintAtomClass,
&hkSetLocalTransformsConstraintAtomClass,
&hkSetLocalTranslationsConstraintAtomClass,
&hkShapeClass,
&hkShapeCollectionClass,
&hkShapeCollectionFilterClass,
&hkShapeContainerClass,
&hkShapePhantomClass,
&hkShapeRayCastInputClass,
&hkSimpleMeshShapeClass,
&hkSimpleMeshShapeTriangleClass,
&hkSimpleShapePhantomClass,
&hkSingleShapeContainerClass,
&hkSkeletalAnimationClass,
&hkSkeletonClass,
&hkSkeletonMapperClass,
&hkSkeletonMapperDataChainMappingClass,
&hkSkeletonMapperDataClass,
&hkSkeletonMapperDataSimpleMappingClass,
&hkSoftContactModifierConstraintAtomClass,
&hkSpatialRigidBodyDeactivatorClass,
&hkSpatialRigidBodyDeactivatorSampleClass,
&hkSphereClass,
&hkSphereMotionClass,
&hkSphereRepShapeClass,
&hkSphereShapeClass,
&hkSpringActionClass,
&hkSpringDamperConstraintMotorClass,
&hkStabilizedBoxMotionClass,
&hkStabilizedSphereMotionClass,
&hkStiffSpringChainDataClass,
&hkStiffSpringChainDataConstraintInfoClass,
&hkStiffSpringConstraintAtomClass,
&hkStiffSpringConstraintDataAtomsClass,
&hkStiffSpringConstraintDataClass,
&hkStorageMeshShapeClass,
&hkStorageMeshShapeSubpartStorageClass,
&hkStorageSampledHeightFieldShapeClass,
&hkSweptTransformClass,
&hkThinBoxMotionClass,
&hkTransformShapeClass,
&hkTriSampledHeightFieldBvTreeShapeClass,
&hkTriSampledHeightFieldCollectionClass,
&hkTriangleShapeClass,
&hkTwistLimitConstraintAtomClass,
&hkTypedBroadPhaseHandleClass,
&hkTyremarkPointClass,
&hkTyremarksInfoClass,
&hkTyremarksWheelClass,
&hkUnaryActionClass,
&hkVehicleAerodynamicsClass,
&hkVehicleBrakeClass,
&hkVehicleDataClass,
&hkVehicleDataWheelComponentParamsClass,
&hkVehicleDefaultAerodynamicsClass,
&hkVehicleDefaultAnalogDriverInputClass,
&hkVehicleDefaultBrakeClass,
&hkVehicleDefaultBrakeWheelBrakingPropertiesClass,
&hkVehicleDefaultEngineClass,
&hkVehicleDefaultSteeringClass,
&hkVehicleDefaultSuspensionClass,
&hkVehicleDefaultSuspensionWheelSpringSuspensionParametersClass,
&hkVehicleDefaultTransmissionClass,
&hkVehicleDefaultVelocityDamperClass,
&hkVehicleDriverInputAnalogStatusClass,
&hkVehicleDriverInputClass,
&hkVehicleDriverInputStatusClass,
&hkVehicleEngineClass,
&hkVehicleFrictionDescriptionAxisDescriptionClass,
&hkVehicleFrictionDescriptionClass,
&hkVehicleFrictionStatusAxisStatusClass,
&hkVehicleFrictionStatusClass,
&hkVehicleInstanceClass,
&hkVehicleInstanceWheelInfoClass,
&hkVehicleRaycastWheelCollideClass,
&hkVehicleSteeringClass,
&hkVehicleSuspensionClass,
&hkVehicleSuspensionSuspensionWheelParametersClass,
&hkVehicleTransmissionClass,
&hkVehicleVelocityDamperClass,
&hkVehicleWheelCollideClass,
&hkVelocityConstraintMotorClass,
&hkVersioningExceptionsArrayClass,
&hkVersioningExceptionsArrayVersioningExceptionClass,
&hkViscousSurfaceModifierConstraintAtomClass,
&hkWaveletSkeletalAnimationClass,
&hkWaveletSkeletalAnimationQuantizationFormatClass,
&hkWheelConstraintDataAtomsClass,
&hkWheelConstraintDataClass,
&hkWorldCinfoClass,
&hkWorldMemoryWatchDogClass,
&hkWorldObjectClass,
&hkbAdditiveBinaryBlenderGeneratorClass,
&hkbAttributeModifierClass,
&hkbBehaviorClass,
&hkbBinaryBlenderGeneratorClass,
&hkbBlenderGeneratorChildClass,
&hkbBlenderGeneratorClass,
&hkbBlendingTransitionEffectClass,
&hkbCharacterBoneInfoClass,
&hkbCharacterSetupClass,
&hkbClipGeneratorClass,
&hkbClipTriggerClass,
&hkbControlLookAtModifierClass,
&hkbEventClass,
&hkbFootIkControlDataClass,
&hkbFootIkControlsModifierClass,
&hkbFootIkGainsClass,
&hkbFootIkModifierClass,
&hkbGeneratorClass,
&hkbGetUpModifierClass,
&hkbHandIkModifierClass,
&hkbKeyframeDataClass,
&hkbLookAtModifierClass,
&hkbModifierClass,
&hkbModifierGeneratorClass,
&hkbModifierSequenceClass,
&hkbNodeClass,
&hkbPoseMatchingModifierClass,
&hkbPoweredRagdollControlDataClass,
&hkbPoweredRagdollControlsModifierClass,
&hkbPoweredRagdollModifierClass,
&hkbPredicateClass,
&hkbRagdollDriverModifierClass,
&hkbReachModifierClass,
&hkbReferencePoseGeneratorClass,
&hkbRigidBodyRagdollControlDataClass,
&hkbRigidBodyRagdollControlsModifierClass,
&hkbRigidBodyRagdollModifierClass,
&hkbStateMachineClass,
&hkbStateMachineIntervalClass,
&hkbStateMachineStateInfoClass,
&hkbStateMachineTransitionInfoClass,
&hkbStringPredicateClass,
&hkbTransitionEffectClass,
&hkbVariableSetClass,
&hkbVariableSetTargetClass,
&hkbVariableSetVariableClass,
&hkxAnimatedFloatClass,
&hkxAnimatedMatrixClass,
&hkxAnimatedQuaternionClass,
&hkxAnimatedVectorClass,
&hkxAttributeClass,
&hkxAttributeGroupClass,
&hkxCameraClass,
&hkxEnvironmentClass,
&hkxEnvironmentVariableClass,
&hkxIndexBufferClass,
&hkxLightClass,
&hkxMaterialClass,
&hkxMaterialEffectClass,
&hkxMaterialTextureStageClass,
&hkxMeshClass,
&hkxMeshSectionClass,
&hkxNodeAnnotationDataClass,
&hkxNodeClass,
&hkxSceneClass,
&hkxSkinBindingClass,
&hkxSparselyAnimatedBoolClass,
&hkxSparselyAnimatedEnumClass,
&hkxSparselyAnimatedIntClass,
&hkxSparselyAnimatedStringClass,
&hkxSparselyAnimatedStringStringTypeClass,
&hkxTextureFileClass,
&hkxTextureInplaceClass,
&hkxVertexBufferClass,
&hkxVertexFormatClass,
&hkxVertexP4N4C1T2Class,
&hkxVertexP4N4T4B4C1T2Class,
&hkxVertexP4N4T4B4W4I4C1Q2Class,
&hkxVertexP4N4T4B4W4I4Q4Class,
&hkxVertexP4N4W4I4C1Q2Class,
HK_NULL
};
const hkStaticClassNameRegistry hkHavokDefaultClassRegistry
(
Classes,
ClassVersion,
VersionString
);
} // namespace hkHavok410b1Classes
/*
* Havok SDK - Base file, BUILD(#20130912)
*
* Confidential Information of Havok. (C) Copyright 1999-2013
* Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
* Logo, and the Havok buzzsaw logo are trademarks of Havok. Title, ownership
* rights, and intellectual property rights in the Havok software remain in
* Havok and/or its suppliers.
*
* Use of this software for evaluation purposes is subject to and indicates
* acceptance of the End User licence Agreement for this product. A copy of
* the license is included with this software and is also available from salesteam@havok.com.
*
*/
| [
"dingfengyu@gmail.com"
] | dingfengyu@gmail.com |
f139f7a102861356c76edeb3433dd2cc15de6733 | 36c31b485a5906ab514c964491b8f001a70a67f5 | /Codeforces/CF 1600 - 1699/CF1605/CF1605B.cpp | 4341096114749e99675c4727b9b81dff6baceda7 | [] | no_license | SMiles02/CompetitiveProgramming | 77926918d5512824900384639955b31b0d0a5841 | 035040538c7e2102a88a2e3587e1ca984a2d9568 | refs/heads/master | 2023-08-18T22:14:09.997704 | 2023-08-13T20:30:42 | 2023-08-13T20:30:42 | 277,504,801 | 25 | 5 | null | 2022-11-01T01:34:30 | 2020-07-06T09:54:44 | C++ | UTF-8 | C++ | false | false | 1,635 | cpp | //#pragma GCC optimize("Ofast,unroll-loops")
//#pragma GCC target("avx,avx2,sse,sse2")
#include <bits/stdc++.h>
#define ll long long
#define sz(x) (int)(x).size()
using namespace std;
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
//uniform_int_distribution<int>(1000,10000)(rng)
ll binpow(ll a, ll b)
{
ll res = 1;
while (b > 0)
{
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
ll gcd(ll a,ll b)
{
if (b==0) return a;
return gcd(b,a%b);
}
string to_upper(string a)
{
for (int i=0;i<(int)a.size();++i) if (a[i]>='a' && a[i]<='z') a[i]-='a'-'A';
return a;
}
string to_lower(string a)
{
for (int i=0;i<(int)a.size();++i) if (a[i]>='A' && a[i]<='Z') a[i]+='a'-'A';
return a;
}
void solve()
{
int n;
cin>>n;
string s,t;
cin>>s;
t=s;
sort(t.begin(), t.end());
vector<vector<int>> v;
for (int i=0;i<n;++i)
if (s[i]!=t[i])
{
if (s[i]=='1')
{
if (sz(v)==0||(sz(v)>0&&s[v.back().back()]=='0'))
v.push_back({});
v.back().push_back(i);
}
else
{
if (sz(v)==0)
v.push_back({});
v[0].push_back(i);
}
}
cout<<sz(v)<<"\n";
for (auto i : v)
{
cout<<sz(i)<<" ";
for (auto j : i)
cout<<j+1<<" ";
cout<<"\n";
}
}
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
int t;
cin>>t;
while (t--)
solve();
return 0;
} | [
"mahajan.suneet2002@gmail.com"
] | mahajan.suneet2002@gmail.com |
0617ff42fd5b06edce0d74a149905cccab709762 | ee0d55c98ffa9519552f014150457d45384fc394 | /Multi-Level-Queue/lib/PriorityQueue/displayQueues.hpp | 90110463ac98f79d67ed38ebae5c7d6753ed8a38 | [] | no_license | Ritvik-Gupta/CPU-Scheduling-Algorithms---CPP | 2237dc6ecf9d24795c081ee1b88d92f1f81a1699 | 7949a9fe128a00b6ab45329c30877de43b625281 | refs/heads/master | 2023-01-08T16:46:16.543521 | 2020-11-06T17:11:12 | 2020-11-06T17:11:12 | 301,889,671 | 0 | 0 | null | 2020-11-06T17:11:13 | 2020-10-07T00:42:46 | C++ | UTF-8 | C++ | false | false | 3,498 | hpp | #ifndef SYMBOL_displayQueues_1602686063
#define SYMBOL_displayQueues_1602686063
#include <iostream>
#include <iomanip>
using namespace std;
#include "./PriorityQueue.hpp"
#include "../services.hpp"
void PriorityQueue::displayQueues(vector<PriorityQueue*>* priorityQueues) {
unsigned maxWaitingQueueSize = 1;
for (auto itr = priorityQueues->begin();itr != priorityQueues->end();++itr) {
if ((*itr)->waitingQueue->size() > maxWaitingQueueSize)
maxWaitingQueueSize = (*itr)->waitingQueue->size();
}
cout << endl << endl;
ColorPalette::add(YELLOW);
vertiDiv(DELIMETER);
partition(2, DELIMETER, false);
vertiDiv(DELIMETER);
partition(priorityQueues->size(), DELIMETER);
vertiDiv(EMPTY);
cout << endl;
vertiDiv(EMPTY);
partition(2, EMPTY, false);
vertiDiv(EMPTY);
for (PriorityQueue* queue : *priorityQueues) {
vertiDiv(EMPTY);
ColorPalette::add(GRAY);
cout << setw(horizWidth) << queue->getName();
ColorPalette::remove();
}
vertiDiv(EMPTY);
cout << endl;
vertiDiv(DELIMETER);
partition(2, DELIMETER, false);
vertiDiv(DELIMETER);
partition(priorityQueues->size(), DELIMETER);
vertiDiv(EMPTY);
cout << endl;
vertiDiv(DELIMETER);
partition(2, DELIMETER, false);
vertiDiv(EMPTY);
ColorPalette::add(WHITE);
partition(priorityQueues->size(), DELIMETER);
vertiDiv(EMPTY);
ColorPalette::remove();
cout << endl;
vertiDiv(EMPTY);
ColorPalette::add(LIGHT_YELLOW);
cout << setw(2 * horizWidth) << "Running Process";
ColorPalette::remove();
vertiDiv(EMPTY);
ColorPalette::add(WHITE);
for (auto itr = priorityQueues->begin();itr != priorityQueues->end();++itr) {
vertiDiv(EMPTY);
ColorPalette::add((*itr)->running != NULL ? AQUA : GRAY);
cout << setw(horizWidth) << ((*itr)->running != NULL ? (*itr)->running->getId() : "-");
ColorPalette::remove();
}
vertiDiv(EMPTY);
ColorPalette::remove();
cout << endl;
vertiDiv(DELIMETER);
partition(2, DELIMETER, false);
vertiDiv(EMPTY);
ColorPalette::add(WHITE);
partition(priorityQueues->size(), DELIMETER);
vertiDiv(EMPTY);
ColorPalette::remove();
cout << endl;
vertiDiv(DELIMETER);
partition(2, DELIMETER, false);
vertiDiv(EMPTY);
ColorPalette::add(WHITE);
partition(priorityQueues->size(), DELIMETER);
vertiDiv(EMPTY);
ColorPalette::remove();
cout << endl;
for (unsigned i = 0;i < maxWaitingQueueSize;++i) {
vertiDiv(EMPTY);
ColorPalette::add(LIGHT_YELLOW);
cout << setw(2 * horizWidth) << (i == 0 ? "Waiting Queue" : "*");
ColorPalette::remove();
vertiDiv(EMPTY);
ColorPalette::add(WHITE);
for (auto itr = priorityQueues->begin();itr != priorityQueues->end();++itr) {
vertiDiv(EMPTY);
if (i < (*itr)->waitingQueue->size()) {
ColorPalette::add(AQUA);
cout << setw(horizWidth) << (*itr)->waitingQueue->at(i)->getId();
} else {
ColorPalette::add(GRAY);
cout << setw(horizWidth) << "-";
}
ColorPalette::remove();
}
vertiDiv(EMPTY);
ColorPalette::remove();
cout << endl;
vertiDiv(DELIMETER);
partition(2, DELIMETER, false);
vertiDiv(DELIMETER);
ColorPalette::add(WHITE);
partition(priorityQueues->size(), DELIMETER);
vertiDiv(EMPTY);
ColorPalette::remove();
cout << endl;
}
ColorPalette::clear();
}
#endif
| [
"ritvik.gupta2019@vitstudent.ac.in"
] | ritvik.gupta2019@vitstudent.ac.in |
352cacea2efd5d8f73b966610ea8b579a9008ccc | 16e2144d333e6a8399e1ef34f16d2513160193e3 | /main.cpp | 183180f127b4cd72fe7412aa9e2d7c3dcf7213bf | [] | no_license | kwarkGorny/DynamikaKwantowaCzastki | 3006bf253914e97897291170f8225fce4b376f22 | 1f70aca4fe3ababd63c7893de16d0fad693a61d3 | refs/heads/master | 2020-04-05T09:59:04.546174 | 2018-11-08T23:44:16 | 2018-11-08T23:44:16 | 156,783,153 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 756 | cpp | #pragma once
#define _USE_MATH_DEFINES
#include <chrono>
#include <array>
#include <string>
#include "WaveFunction.h"
int main()
{
const auto t1 = std::chrono::high_resolution_clock::now();
{
constexpr float omega = 0.5 * 3 * M_PI*M_PI;
constexpr std::array<float, 10> omegaMultipliers = { 0.9, 0.92, 0.94, 0.98, 1, 1.02, 1.04, 1.06, 1.08, 1.1 };
for (int ii=0; ii< omegaMultipliers.size(); ++ii)
{
printf("omega id: %d\n", ii);
WaveFunction wave;
wave.Simulation(omega*omegaMultipliers[ii], "results/omega" + std::to_string(ii) + ".txt");
}
}
const auto t2 = std::chrono::high_resolution_clock::now();
printf("took %lld ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count());
return 0;
} | [
"Adm.Szc@wp.pl"
] | Adm.Szc@wp.pl |
bf515dc9a5b57f20abe642c448894a8a230f1313 | ce1a26e7a340fd69eb617bd7be33f3d209a8f7d6 | /Inzynieria oprogramowania/ćwiczenia1/C++/main.cpp | eefdee4d813571f1f1094832949b499bc32de795 | [] | no_license | JakubMakaruk/UMCS | 7dd85eafce944af9cd8f53f3f298e873af22c72a | 9913d6ee799a3324d9f02d41458fb6212b2d715b | refs/heads/master | 2022-03-03T18:24:55.451001 | 2022-02-11T21:14:33 | 2022-02-11T21:14:33 | 243,956,817 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 922 | cpp | #include <iostream>
using namespace std;
class Zwierze
{
int wiek;
public:
int getWiek() { return this->wiek; }
void setWiek(int w) { this->wiek = w; }
};
class Ssak : public Zwierze
{
double dlugosc = 0;
public:
double getDlugosc() { return this->dlugosc; }
void setDlugosc(double d) { this->dlugosc = d; }
};
class Pies : public Ssak
{
string rasa;
public:
string getRasa() { return this->rasa; }
void siad()
{
cout << "Siadam!" << endl;
}
};
class Jamnik : public Pies
{
string kolor;
public:
string getKolor() { return this->kolor; }
void setKolor(string k) { this->kolor = k; }
void zmierzDlugosc()
{
cout << "Jamnik ma " << this->getDlugosc() << "m." << endl;
}
};
int main()
{
Jamnik j;
j.setDlugosc(10);
j.setWiek(5);
j.siad();
j.zmierzDlugosc();
cout << j.getWiek() << endl;
return 0;
}
| [
"jakub.makaruk@gmail.com"
] | jakub.makaruk@gmail.com |
5861ffb8c7cc55d6c276f148f951a6135da22c8c | 4ecf14e0bbe105958d83e5fad014a1cd014e669d | /gfx/angle/src/tests/gl_tests/ShaderStorageBufferTest.cpp | 01317bbd7656f8157dca6a42f58b83f359a75d0f | [
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause"
] | permissive | fx-dev-playground/gecko | 2c1a13a51f00645f8bfc35c9ec71a4d40b8c8dc2 | 889acebc871804214ab2579e434d7633e271e5cb | refs/heads/central_default | 2023-01-27T11:13:44.498662 | 2018-01-16T21:43:19 | 2018-01-16T21:43:19 | 64,968,340 | 8 | 13 | NOASSERTION | 2023-01-11T07:47:54 | 2016-08-04T21:24:19 | null | UTF-8 | C++ | false | false | 4,161 | cpp | //
// Copyright 2017 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// ShaderStorageBufferTest:
// Various tests related for shader storage buffers.
//
#include "test_utils/ANGLETest.h"
#include "test_utils/gl_raii.h"
using namespace angle;
namespace
{
class ShaderStorageBufferTest31 : public ANGLETest
{
protected:
ShaderStorageBufferTest31()
{
setWindowWidth(128);
setWindowHeight(128);
setConfigRedBits(8);
setConfigGreenBits(8);
setConfigBlueBits(8);
setConfigAlphaBits(8);
}
};
// Matched block names within a shader interface must match in terms of having the same number of
// declarations with the same sequence of types.
TEST_P(ShaderStorageBufferTest31, MatchedBlockNameWithDifferentMemberType)
{
const std::string &vertexShaderSource =
"#version 310 es\n"
"buffer blockName {\n"
" float data;\n"
"};\n"
"void main()\n"
"{\n"
"}\n";
const std::string &fragmentShaderSource =
"#version 310 es\n"
"buffer blockName {\n"
" uint data;\n"
"};\n"
"void main()\n"
"{\n"
"}\n";
GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
EXPECT_EQ(0u, program);
}
// Linking should fail if blocks in vertex shader exceed GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS.
TEST_P(ShaderStorageBufferTest31, ExceedMaxVertexShaderStorageBlocks)
{
std::ostringstream instanceCount;
GLint maxVertexShaderStorageBlocks;
glGetIntegerv(GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS, &maxVertexShaderStorageBlocks);
instanceCount << maxVertexShaderStorageBlocks;
const std::string &vertexShaderSource =
"#version 310 es\n"
"layout(shared) buffer blockName {\n"
" uint data;\n"
"} instance[" +
instanceCount.str() +
" + 1];\n"
"void main()\n"
"{\n"
"}\n";
const std::string &fragmentShaderSource =
"#version 310 es\n"
"void main()\n"
"{\n"
"}\n";
GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
EXPECT_EQ(0u, program);
}
// Test shader storage buffer read write.
TEST_P(ShaderStorageBufferTest31, ShaderStorageBufferReadWrite)
{
// TODO(jiajia.qin@intel.com): Figure out why it fails on AMD platform.
ANGLE_SKIP_TEST_IF(IsAMD() && IsDesktopOpenGL());
ANGLE_SKIP_TEST_IF(IsLinux() && IsIntel() && IsOpenGL());
const std::string &csSource =
"#version 310 es\n"
"layout(local_size_x=1, local_size_y=1, local_size_z=1) in;\n"
"layout(binding = 1) buffer blockName {\n"
" uint data[2];\n"
"} instanceName;\n"
"void main()\n"
"{\n"
" instanceName.data[0] = 3u;\n"
" if (instanceName.data[0] == 3u)\n"
" instanceName.data[1] = 4u;\n"
" else\n"
" instanceName.data[1] = 5u;\n"
"}\n";
ANGLE_GL_COMPUTE_PROGRAM(program, csSource);
glUseProgram(program.get());
unsigned int bufferData[2] = {0u};
// Create shader storage buffer
GLBuffer shaderStorageBuffer;
glBindBuffer(GL_SHADER_STORAGE_BUFFER, shaderStorageBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(bufferData), nullptr, GL_STATIC_DRAW);
// Bind shader storage buffer
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, shaderStorageBuffer);
// Dispath compute
glDispatchCompute(1, 1, 1);
glFinish();
// Read back shader storage buffer
glBindBuffer(GL_SHADER_STORAGE_BUFFER, shaderStorageBuffer);
void *ptr = glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(bufferData), GL_MAP_READ_BIT);
memcpy(bufferData, ptr, sizeof(bufferData));
glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
EXPECT_EQ(3u, bufferData[0]);
EXPECT_EQ(4u, bufferData[1]);
EXPECT_GL_NO_ERROR();
}
ANGLE_INSTANTIATE_TEST(ShaderStorageBufferTest31, ES31_OPENGL(), ES31_OPENGLES());
} // namespace
| [
"cleu@mozilla.com"
] | cleu@mozilla.com |
90b393777c4e1294f5775bb94b0ccc06279dc6b4 | 91a882547e393d4c4946a6c2c99186b5f72122dd | /Source/XPSP1/NT/base/fs/hsm/job/hsmpolcy.h | 99e47d3a4ba5c043db4722974d093b865a9862e2 | [] | no_license | IAmAnubhavSaini/cryptoAlgorithm-nt5src | 94f9b46f101b983954ac6e453d0cf8d02aa76fc7 | d9e1cdeec650b9d6d3ce63f9f0abe50dabfaf9e2 | refs/heads/master | 2023-09-02T10:14:14.795579 | 2021-11-20T13:47:06 | 2021-11-20T13:47:06 | null | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 2,301 | h | #ifndef _HSMPOLCY_
#define _HSMPOLCY_
/*++
© 1998 Seagate Software, Inc. All rights reserved.
Module Name:
hsmrule.cpp
Abstract:
This component represents a job's policy.
Author:
Chuck Bardeen [cbardeen] 29-Oct-1996
Revision History:
--*/
#include "resource.h" // main symbols
#include "wsb.h"
/*++
Class Name:
CHsmPolicy
Class Description:
This component represents a job's policy.
--*/
class CHsmPolicy :
public IHsmPolicy,
public CWsbObject,
public CComCoClass<CHsmPolicy,&CLSID_CHsmPolicy>
{
public:
CHsmPolicy() {}
BEGIN_COM_MAP(CHsmPolicy)
COM_INTERFACE_ENTRY(IHsmPolicy)
COM_INTERFACE_ENTRY2(IPersist, IPersistStream)
COM_INTERFACE_ENTRY(IPersistStream)
COM_INTERFACE_ENTRY(IWsbCollectable)
COM_INTERFACE_ENTRY(IWsbTestable)
END_COM_MAP()
DECLARE_REGISTRY_RESOURCEID(IDR_CHsmPolicy)
// CComObjectRoot
public:
STDMETHOD(FinalConstruct)(void);
// IPersist
public:
STDMETHOD(GetClassID)(LPCLSID pClsid);
// IPersistStream
public:
STDMETHOD(GetSizeMax)(ULARGE_INTEGER* pSize);
STDMETHOD(Load)(IStream* pStream);
STDMETHOD(Save)(IStream* pStream, BOOL clearDirty);
// IWsbCollectable
public:
STDMETHOD(CompareTo)(IUnknown* pUnknown, SHORT* pResult);
// IWsbTestable
STDMETHOD(Test)(USHORT *passed, USHORT* failed);
// IHsmPolicy
public:
STDMETHOD(CompareToIdentifier)(GUID id, SHORT* pResult);
STDMETHOD(CompareToIPolicy)(IHsmPolicy* pPolicy, SHORT* pResult);
STDMETHOD(EnumRules)(IWsbEnum** ppEnum);
STDMETHOD(GetAction)(IHsmAction** ppAction);
STDMETHOD(GetIdentifier)(GUID* pId);
STDMETHOD(GetName)(OLECHAR** pName, ULONG bufferSize);
STDMETHOD(GetScale)(USHORT* pScale);
STDMETHOD(Rules)(IWsbCollection** ppWsbCollection);
STDMETHOD(SetAction)(IHsmAction* pAction);
STDMETHOD(SetName)(OLECHAR* name);
STDMETHOD(SetScale)(USHORT scale);
STDMETHOD(SetUsesDefaultRules)(BOOL usesDefaults);
STDMETHOD(UsesDefaultRules)(void);
protected:
GUID m_id;
CWsbStringPtr m_name;
USHORT m_scale;
BOOL m_usesDefaultRules;
CComPtr<IHsmAction> m_pAction;
CComPtr<IWsbCollection> m_pRules;
};
#endif // _HSMPOLCY_
| [
"support@cryptoalgo.cf"
] | support@cryptoalgo.cf |
e8cec245c6acf58d2ea4deef77d53330953428e7 | 6b2a8dd202fdce77c971c412717e305e1caaac51 | /solutions_5658282861527040_0/C++/tony412/pb.cpp | 460c514f4836878cbd909d682220c1e20624ecca | [] | no_license | alexandraback/datacollection | 0bc67a9ace00abbc843f4912562f3a064992e0e9 | 076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf | refs/heads/master | 2021-01-24T18:27:24.417992 | 2017-05-23T09:23:38 | 2017-05-23T09:23:38 | 84,313,442 | 2 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 330 | cpp | #include <stdio.h>
int main()
{
int T, C;
int a, b, k, i, j;
int ans;
scanf("%d", &T);
for (C = 1; C <= T; C++)
{
scanf("%d %d %d", &a, &b, &k);
ans = 0;
for (i = 0; i < a; i++)
for (j = 0; j < b; j++)
{
if ((i & j) < k)
ans++;
}
printf("Case #%d: ", C);
printf("%d\n", ans);
}
return 0;
}
| [
"eewestman@gmail.com"
] | eewestman@gmail.com |
dd38b5d7285fc38e8546c302b8704bc76f88cc7d | 9eb8913126c2b4a608ac2defa7108a46c15f828f | /FireflyEngine/src/Rendering/Vulkan/VulkanMaterial.cpp | 4e4df50f252fd3ab56459bc651ea65929e1ca7f9 | [
"MIT"
] | permissive | GitDaroth/FireflyEngine | 1b13e8b32f0f8062981efe17882a233d35b44fe5 | ea19a6a7f283e25eb989b2a499297e0834024c0b | refs/heads/master | 2023-06-27T19:11:31.901728 | 2021-07-18T11:53:01 | 2021-07-18T11:53:01 | 267,032,715 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,690 | cpp | #include "pch.h"
#include "Rendering/Vulkan/VulkanMaterial.h"
#include "Rendering/RenderingAPI.h"
#include "Rendering/Vulkan/VulkanContext.h"
#include "Rendering/Vulkan/VulkanTexture.h"
namespace Firefly
{
VulkanMaterial::VulkanMaterial() :
Material()
{
std::shared_ptr<VulkanContext> vkContext = std::dynamic_pointer_cast<VulkanContext>(RenderingAPI::GetContext());
m_device = vkContext->GetDevice()->GetHandle();
m_descriptorPool = vkContext->GetDescriptorPool();
}
void VulkanMaterial::Destroy()
{
m_device.destroyDescriptorSetLayout(m_materialTexturesDescriptorSetLayout);
}
vk::DescriptorSet VulkanMaterial::GetTexturesDescriptorSet() const
{
return m_materialTexturesDescriptorSet;
}
void VulkanMaterial::OnInit()
{
vk::DescriptorSetLayoutBinding albedoTextureLayoutBinding{};
albedoTextureLayoutBinding.binding = 0;
albedoTextureLayoutBinding.descriptorType = vk::DescriptorType::eCombinedImageSampler;
albedoTextureLayoutBinding.descriptorCount = 1;
albedoTextureLayoutBinding.stageFlags = vk::ShaderStageFlagBits::eFragment;
albedoTextureLayoutBinding.pImmutableSamplers = nullptr;
vk::DescriptorSetLayoutBinding normalTextureLayoutBinding{};
normalTextureLayoutBinding.binding = 1;
normalTextureLayoutBinding.descriptorType = vk::DescriptorType::eCombinedImageSampler;
normalTextureLayoutBinding.descriptorCount = 1;
normalTextureLayoutBinding.stageFlags = vk::ShaderStageFlagBits::eFragment;
normalTextureLayoutBinding.pImmutableSamplers = nullptr;
vk::DescriptorSetLayoutBinding roughnessTextureLayoutBinding{};
roughnessTextureLayoutBinding.binding = 2;
roughnessTextureLayoutBinding.descriptorType = vk::DescriptorType::eCombinedImageSampler;
roughnessTextureLayoutBinding.descriptorCount = 1;
roughnessTextureLayoutBinding.stageFlags = vk::ShaderStageFlagBits::eFragment;
roughnessTextureLayoutBinding.pImmutableSamplers = nullptr;
vk::DescriptorSetLayoutBinding metalnessTextureLayoutBinding{};
metalnessTextureLayoutBinding.binding = 3;
metalnessTextureLayoutBinding.descriptorType = vk::DescriptorType::eCombinedImageSampler;
metalnessTextureLayoutBinding.descriptorCount = 1;
metalnessTextureLayoutBinding.stageFlags = vk::ShaderStageFlagBits::eFragment;
metalnessTextureLayoutBinding.pImmutableSamplers = nullptr;
vk::DescriptorSetLayoutBinding occlusionTextureLayoutBinding{};
occlusionTextureLayoutBinding.binding = 4;
occlusionTextureLayoutBinding.descriptorType = vk::DescriptorType::eCombinedImageSampler;
occlusionTextureLayoutBinding.descriptorCount = 1;
occlusionTextureLayoutBinding.stageFlags = vk::ShaderStageFlagBits::eFragment;
occlusionTextureLayoutBinding.pImmutableSamplers = nullptr;
vk::DescriptorSetLayoutBinding heightTextureLayoutBinding{};
heightTextureLayoutBinding.binding = 5;
heightTextureLayoutBinding.descriptorType = vk::DescriptorType::eCombinedImageSampler;
heightTextureLayoutBinding.descriptorCount = 1;
heightTextureLayoutBinding.stageFlags = vk::ShaderStageFlagBits::eFragment;
heightTextureLayoutBinding.pImmutableSamplers = nullptr;
std::vector<vk::DescriptorSetLayoutBinding> bindings =
{
albedoTextureLayoutBinding,
normalTextureLayoutBinding,
roughnessTextureLayoutBinding,
metalnessTextureLayoutBinding,
occlusionTextureLayoutBinding,
heightTextureLayoutBinding
};
// PartiallyBound: (PhysicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound needs to be enabled)
// -> Allows to update only part of the combined image sampler descriptors with actual data
// UpdateAfterBind: (PhysicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind needs to be enabled)
// -> Allows to update a combined image sampler descriptor on the fly -> corres. flag needs to be set in DescriptorSetLayoutCreateInfo and DescriptorPoolCreateInfo
std::vector<vk::DescriptorBindingFlags> bindingFlags(bindings.size(), vk::DescriptorBindingFlagBits::ePartiallyBound | vk::DescriptorBindingFlagBits::eUpdateAfterBind);
vk::DescriptorSetLayoutBindingFlagsCreateInfo layoutBindingFlagsCreateInfo{};
layoutBindingFlagsCreateInfo.pNext = nullptr;
layoutBindingFlagsCreateInfo.bindingCount = bindingFlags.size();
layoutBindingFlagsCreateInfo.pBindingFlags = bindingFlags.data();
vk::DescriptorSetLayoutCreateInfo materialTexturesDescriptorSetLayoutCreateInfo{};
materialTexturesDescriptorSetLayoutCreateInfo.pNext = &layoutBindingFlagsCreateInfo;
materialTexturesDescriptorSetLayoutCreateInfo.flags = vk::DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool; // Needed in order to update textures on the fly
materialTexturesDescriptorSetLayoutCreateInfo.bindingCount = bindings.size();
materialTexturesDescriptorSetLayoutCreateInfo.pBindings = bindings.data();
vk::Result result = m_device.createDescriptorSetLayout(&materialTexturesDescriptorSetLayoutCreateInfo, nullptr, &m_materialTexturesDescriptorSetLayout);
FIREFLY_ASSERT(result == vk::Result::eSuccess, "Unable to allocate Vulkan descriptor set layout!");
vk::DescriptorSetAllocateInfo descriptorSetAllocateInfo{};
descriptorSetAllocateInfo.pNext = nullptr;
descriptorSetAllocateInfo.descriptorPool = m_descriptorPool;
descriptorSetAllocateInfo.descriptorSetCount = 1;
descriptorSetAllocateInfo.pSetLayouts = &m_materialTexturesDescriptorSetLayout;
result = m_device.allocateDescriptorSets(&descriptorSetAllocateInfo, &m_materialTexturesDescriptorSet);
FIREFLY_ASSERT(result == vk::Result::eSuccess, "Unable to allocate Vulkan descriptor sets!");
}
void VulkanMaterial::OnSetTexture(std::shared_ptr<Texture> texture, TextureUsage usage)
{
uint32_t binding = 0;
switch (usage)
{
case TextureUsage::Albedo:
binding = 0;
break;
case TextureUsage::Normal:
binding = 1;
break;
case TextureUsage::Roughness:
binding = 2;
break;
case TextureUsage::Metalness:
binding = 3;
break;
case TextureUsage::Occlusion:
binding = 4;
break;
case TextureUsage::Height:
binding = 5;
break;
}
std::shared_ptr<VulkanTexture> vkTexture = std::dynamic_pointer_cast<VulkanTexture>(texture);
vk::DescriptorImageInfo descriptorImageInfo{};
descriptorImageInfo.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
descriptorImageInfo.imageView = vkTexture->GetImageView();
descriptorImageInfo.sampler = vkTexture->GetSampler();
vk::WriteDescriptorSet writeDescriptorSet{};
writeDescriptorSet.dstSet = m_materialTexturesDescriptorSet;
writeDescriptorSet.dstBinding = binding;
writeDescriptorSet.dstArrayElement = 0;
writeDescriptorSet.descriptorType = vk::DescriptorType::eCombinedImageSampler;
writeDescriptorSet.descriptorCount = 1;
writeDescriptorSet.pBufferInfo = nullptr;
writeDescriptorSet.pImageInfo = &descriptorImageInfo;
writeDescriptorSet.pTexelBufferView = nullptr;
m_device.updateDescriptorSets(1, &writeDescriptorSet, 0, nullptr);
}
} | [
"fabian.gulde@gmx.de"
] | fabian.gulde@gmx.de |
bfcae4549a19e0475b67245067947fb750b79e0b | 10a921d63bcbee56e00cfacb809d430d8bafec8a | /third_party/ceres-solver/internal/ceres/unsymmetric_linear_solver_test.cc | 0b82e6a8912da1a03d34145f0b1f38f07a6da46a | [
"BSD-3-Clause"
] | permissive | zyxrrr/GraphSfM | b527383c09fcbf6a89fb848266d61e5e130dcb27 | 1af22ec17950ffc8a5c737a6a46f4465c40aa470 | refs/heads/master | 2020-04-23T02:48:42.557291 | 2019-03-26T02:41:10 | 2019-03-26T02:41:10 | 170,858,089 | 0 | 0 | BSD-3-Clause | 2019-02-15T11:57:46 | 2019-02-15T11:57:46 | null | UTF-8 | C++ | false | false | 8,777 | cc | // Ceres Solver - A fast non-linear least squares minimizer
// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
// http://code.google.com/p/ceres-solver/
//
// 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.
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
#include "ceres/casts.h"
#include "ceres/compressed_row_sparse_matrix.h"
#include "ceres/internal/scoped_ptr.h"
#include "ceres/linear_least_squares_problems.h"
#include "ceres/linear_solver.h"
#include "ceres/triplet_sparse_matrix.h"
#include "ceres/types.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
namespace ceres {
namespace internal {
class UnsymmetricLinearSolverTest : public ::testing::Test {
protected :
virtual void SetUp() {
scoped_ptr<LinearLeastSquaresProblem> problem(
CreateLinearLeastSquaresProblemFromId(0));
CHECK_NOTNULL(problem.get());
A_.reset(down_cast<TripletSparseMatrix*>(problem->A.release()));
b_.reset(problem->b.release());
D_.reset(problem->D.release());
sol_unregularized_.reset(problem->x.release());
sol_regularized_.reset(problem->x_D.release());
}
void TestSolver(const LinearSolver::Options& options) {
LinearSolver::PerSolveOptions per_solve_options;
LinearSolver::Summary unregularized_solve_summary;
LinearSolver::Summary regularized_solve_summary;
Vector x_unregularized(A_->num_cols());
Vector x_regularized(A_->num_cols());
scoped_ptr<SparseMatrix> transformed_A;
if (options.type == DENSE_QR ||
options.type == DENSE_NORMAL_CHOLESKY) {
transformed_A.reset(new DenseSparseMatrix(*A_));
} else if (options.type == SPARSE_NORMAL_CHOLESKY) {
CompressedRowSparseMatrix* crsm = new CompressedRowSparseMatrix(*A_);
// Add row/column blocks structure.
for (int i = 0; i < A_->num_rows(); ++i) {
crsm->mutable_row_blocks()->push_back(1);
}
for (int i = 0; i < A_->num_cols(); ++i) {
crsm->mutable_col_blocks()->push_back(1);
}
transformed_A.reset(crsm);
} else {
LOG(FATAL) << "Unknown linear solver : " << options.type;
}
// Unregularized
scoped_ptr<LinearSolver> solver(LinearSolver::Create(options));
unregularized_solve_summary =
solver->Solve(transformed_A.get(),
b_.get(),
per_solve_options,
x_unregularized.data());
// Sparsity structure is changing, reset the solver.
solver.reset(LinearSolver::Create(options));
// Regularized solution
per_solve_options.D = D_.get();
regularized_solve_summary =
solver->Solve(transformed_A.get(),
b_.get(),
per_solve_options,
x_regularized.data());
EXPECT_EQ(unregularized_solve_summary.termination_type,
LINEAR_SOLVER_SUCCESS);
for (int i = 0; i < A_->num_cols(); ++i) {
EXPECT_NEAR(sol_unregularized_[i], x_unregularized[i], 1e-8)
<< "\nExpected: "
<< ConstVectorRef(sol_unregularized_.get(), A_->num_cols()).transpose()
<< "\nActual: " << x_unregularized.transpose();
}
EXPECT_EQ(regularized_solve_summary.termination_type,
LINEAR_SOLVER_SUCCESS);
for (int i = 0; i < A_->num_cols(); ++i) {
EXPECT_NEAR(sol_regularized_[i], x_regularized[i], 1e-8)
<< "\nExpected: "
<< ConstVectorRef(sol_regularized_.get(), A_->num_cols()).transpose()
<< "\nActual: " << x_regularized.transpose();
}
}
scoped_ptr<TripletSparseMatrix> A_;
scoped_array<double> b_;
scoped_array<double> D_;
scoped_array<double> sol_unregularized_;
scoped_array<double> sol_regularized_;
};
TEST_F(UnsymmetricLinearSolverTest, EigenDenseQR) {
LinearSolver::Options options;
options.type = DENSE_QR;
options.dense_linear_algebra_library_type = EIGEN;
TestSolver(options);
}
TEST_F(UnsymmetricLinearSolverTest, EigenDenseNormalCholesky) {
LinearSolver::Options options;
options.dense_linear_algebra_library_type = EIGEN;
options.type = DENSE_NORMAL_CHOLESKY;
TestSolver(options);
}
#ifndef CERES_NO_LAPACK
TEST_F(UnsymmetricLinearSolverTest, LAPACKDenseQR) {
LinearSolver::Options options;
options.type = DENSE_QR;
options.dense_linear_algebra_library_type = LAPACK;
TestSolver(options);
}
TEST_F(UnsymmetricLinearSolverTest, LAPACKDenseNormalCholesky) {
LinearSolver::Options options;
options.dense_linear_algebra_library_type = LAPACK;
options.type = DENSE_NORMAL_CHOLESKY;
TestSolver(options);
}
#endif
#ifndef CERES_NO_SUITESPARSE
TEST_F(UnsymmetricLinearSolverTest,
SparseNormalCholeskyUsingSuiteSparsePreOrdering) {
LinearSolver::Options options;
options.sparse_linear_algebra_library_type = SUITE_SPARSE;
options.type = SPARSE_NORMAL_CHOLESKY;
options.use_postordering = false;
TestSolver(options);
}
TEST_F(UnsymmetricLinearSolverTest,
SparseNormalCholeskyUsingSuiteSparsePostOrdering) {
LinearSolver::Options options;
options.sparse_linear_algebra_library_type = SUITE_SPARSE;
options.type = SPARSE_NORMAL_CHOLESKY;
options.use_postordering = true;
TestSolver(options);
}
TEST_F(UnsymmetricLinearSolverTest,
SparseNormalCholeskyUsingSuiteSparseDynamicSparsity) {
LinearSolver::Options options;
options.sparse_linear_algebra_library_type = SUITE_SPARSE;
options.type = SPARSE_NORMAL_CHOLESKY;
options.dynamic_sparsity = true;
TestSolver(options);
}
#endif
#ifndef CERES_NO_CXSPARSE
TEST_F(UnsymmetricLinearSolverTest,
SparseNormalCholeskyUsingCXSparsePreOrdering) {
LinearSolver::Options options;
options.sparse_linear_algebra_library_type = CX_SPARSE;
options.type = SPARSE_NORMAL_CHOLESKY;
options.use_postordering = false;
TestSolver(options);
}
TEST_F(UnsymmetricLinearSolverTest,
SparseNormalCholeskyUsingCXSparsePostOrdering) {
LinearSolver::Options options;
options.sparse_linear_algebra_library_type = CX_SPARSE;
options.type = SPARSE_NORMAL_CHOLESKY;
options.use_postordering = true;
TestSolver(options);
}
TEST_F(UnsymmetricLinearSolverTest,
SparseNormalCholeskyUsingCXSparseDynamicSparsity) {
LinearSolver::Options options;
options.sparse_linear_algebra_library_type = CX_SPARSE;
options.type = SPARSE_NORMAL_CHOLESKY;
options.dynamic_sparsity = true;
TestSolver(options);
}
#endif
#ifdef CERES_USE_EIGEN_SPARSE
TEST_F(UnsymmetricLinearSolverTest,
SparseNormalCholeskyUsingEigenPreOrdering) {
LinearSolver::Options options;
options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
options.type = SPARSE_NORMAL_CHOLESKY;
options.use_postordering = false;
TestSolver(options);
}
TEST_F(UnsymmetricLinearSolverTest,
SparseNormalCholeskyUsingEigenPostOrdering) {
LinearSolver::Options options;
options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
options.type = SPARSE_NORMAL_CHOLESKY;
options.use_postordering = true;
TestSolver(options);
}
TEST_F(UnsymmetricLinearSolverTest,
SparseNormalCholeskyUsingEigenDynamicSparsity) {
LinearSolver::Options options;
options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
options.type = SPARSE_NORMAL_CHOLESKY;
options.dynamic_sparsity = true;
TestSolver(options);
}
#endif // CERES_USE_EIGEN_SPARSE
} // namespace internal
} // namespace ceres
| [
"1701213988@pku.edu.cn"
] | 1701213988@pku.edu.cn |
dcc419b23546ac5fbf0638a44d07e10e6a996ed7 | 942b7b337019aa52862bce84a782eab7111010b1 | /xray/xrGame/edge_path_inline.h | 0d7d094fa37960f2be8a5dc4e3882fb931b9bdb7 | [] | no_license | galek/xray15 | 338ad7ac5b297e9e497e223e0fc4d050a4a78da8 | 015c654f721e0fbed1ba771d3c398c8fa46448d9 | refs/heads/master | 2021-11-23T12:01:32.800810 | 2020-01-10T15:52:45 | 2020-01-10T15:52:45 | 168,657,320 | 0 | 0 | null | 2019-02-01T07:11:02 | 2019-02-01T07:11:01 | null | UTF-8 | C++ | false | false | 1,884 | h | ////////////////////////////////////////////////////////////////////////////
// Module : edge_path_inline.h
// Created : 21.03.2002
// Modified : 02.03.2004
// Author : Dmitriy Iassenev
// Description : Edge path class inline functions
////////////////////////////////////////////////////////////////////////////
#pragma once
#define TEMPLATE_SPECIALIZATION \
template<typename _edge_type, bool bEuclidianHeuristics>\
template <template <typename _T> class _vertex>
#define CEdgePathBuilder CEdgePath<_edge_type,bEuclidianHeuristics>::CDataStorage<_vertex>
TEMPLATE_SPECIALIZATION
IC CEdgePathBuilder::CDataStorage (const u32 vertex_count) :
inherited (vertex_count)
{
}
TEMPLATE_SPECIALIZATION
CEdgePathBuilder::~CDataStorage ()
{
}
TEMPLATE_SPECIALIZATION
IC void CEdgePathBuilder::assign_parent (CGraphVertex &neighbour, CGraphVertex *parent)
{
inherited::assign_parent (neighbour,parent);
}
TEMPLATE_SPECIALIZATION
IC void CEdgePathBuilder::assign_parent (CGraphVertex &neighbour, CGraphVertex *parent, const _edge_type &edge)
{
inherited::assign_parent (neighbour,parent);
neighbour.edge() = edge;
}
TEMPLATE_SPECIALIZATION
IC void CEdgePathBuilder::get_edge_path (xr_vector<_edge_type> &path, CGraphVertex *best, bool reverse_order)
{
CGraphVertex *t1 = best, *t2 = best->back();
u32 i = 1;
for (; t2; t1 = t2, t2 = t2->back(), ++i) ;
u32 n = (u32)path.size();
path.resize (n + --i);
t2 = best;
if (!reverse_order) {
typename xr_vector<_edge_type>::reverse_iterator I = path.rbegin();
typename xr_vector<_edge_type>::reverse_iterator E = path.rend();
for (; t2->back() ; t2 = t2->back(), ++I)
*I = t2->edge();
}
else {
typename xr_vector<_edge_type>::iterator I = path.begin() + n;
for (; t2->back() ; t2 = t2->back(), ++I)
*I = t2->edge();
}
}
#undef TEMPLATE_SPECIALIZATION
#undef CEdgePathBuilder | [
"abramcumner@yandex.ru"
] | abramcumner@yandex.ru |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.