blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
8746cfaf76720a64d0c4afb200d3d40f7c7d5a90 | 959a198f0102bb11775c9e69ddc625f9e52f4b63 | /lab4/ShapeDrawing4students/rectangle.cpp | 9b4658054be74e74db1c2f1527ce48291c1a5e32 | [] | no_license | kocimski/CPlusPlusLab | 45d0ba6ddd1b519b185d2c145bee00ba96dabb3c | a8ac1d4315043042a4eb12d7f08a703bb76f68ce | refs/heads/master | 2022-11-10T10:03:27.608478 | 2020-06-25T16:20:08 | 2020-06-25T16:20:08 | 248,291,136 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 322 | cpp | #include "rectangle.h"
#include <iostream>
Shapes::Rectangle::Rectangle(int x, int y, int xTo, int yTo)
{
this->x = x;
this->y = y;
this->xTo = xTo;
this->yTo = yTo;
}
bool Shapes::Rectangle::isIn(int x, int y) const {
return x >= this->x && x <= this -> xTo && y >= this->y && y <= this->yTo;
}
| [
"pawelpoczta1201@o2.pl"
] | pawelpoczta1201@o2.pl |
244cc97ad96430efc9fdcc40769d632708e98174 | fe2362eda423bb3574b651c21ebacbd6a1a9ac2a | /VTK-7.1.1/Common/DataModel/vtkHierarchicalBoxDataIterator.h | 81044a589060bbe0d58b7e907ca3b763e962deac | [
"BSD-3-Clause"
] | permissive | likewatchk/python-pcl | 1c09c6b3e9de0acbe2f88ac36a858fe4b27cfaaf | 2a66797719f1b5af7d6a0d0893f697b3786db461 | refs/heads/master | 2023-01-04T06:17:19.652585 | 2020-10-15T21:26:58 | 2020-10-15T21:26:58 | 262,235,188 | 0 | 0 | NOASSERTION | 2020-05-08T05:29:02 | 2020-05-08T05:29:01 | null | UTF-8 | C++ | false | false | 1,523 | h | /*=========================================================================
Program: Visualization Toolkit
Module: vtkHierarchicalBoxDataIterator.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.
=========================================================================*/
/**
* @class vtkHierarchicalBoxDataIterator
*
*
* Empty class for backwards compatibility.
*/
#ifndef vtkHierarchicalBoxDataIterator_h
#define vtkHierarchicalBoxDataIterator_h
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkUniformGridAMRDataIterator.h"
class VTKCOMMONDATAMODEL_EXPORT vtkHierarchicalBoxDataIterator :
public vtkUniformGridAMRDataIterator
{
public:
static vtkHierarchicalBoxDataIterator* New();
vtkTypeMacro(vtkHierarchicalBoxDataIterator,vtkUniformGridAMRDataIterator);
void PrintSelf(ostream &os, vtkIndent indent) VTK_OVERRIDE;
protected:
vtkHierarchicalBoxDataIterator();
~vtkHierarchicalBoxDataIterator() VTK_OVERRIDE;
private:
vtkHierarchicalBoxDataIterator(const vtkHierarchicalBoxDataIterator&) VTK_DELETE_FUNCTION;
void operator=(const vtkHierarchicalBoxDataIterator&) VTK_DELETE_FUNCTION;
};
#endif /* VTKHIERARCHICALBOXDATAITERATOR_H_ */
| [
"likewatchk@gmail.com"
] | likewatchk@gmail.com |
b1e54cf96478bdc962eea49404946e7a435e6d7a | c4e1b2fad57e164b1ec250d7ef58ca6b325be916 | /Sprout/W13/stringmatching.cpp | 703ac631ff9f088630d4e1677b36937966d03072 | [] | no_license | xSeanliux/CompetitiveProgramming | ab8030fdb0dc9c4e29e4cc8c52e020e6eb564372 | 011c7ad152d7090fa3e9143a27119a2192d68144 | refs/heads/master | 2023-06-08T11:00:48.826892 | 2023-05-25T22:58:43 | 2023-05-25T22:58:43 | 158,057,461 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,119 | cpp |
#include <iostream>
using namespace std;
string s, t;
int main(){
cin >> s >> t;
int ls = s.length(), lt = t.length();
int fail[ls + 10];
fail[0] = -1;
for(int i = 1; i < ls; i++){
int q = fail[i - 1];
while(q > 0 && s[q + 1] != s[i]) q = fail[q];
if(s[q + 1] == s[i]) q++;
fail[i] = q;
}
int matched = 0, currentInd = 0;
for(int i = 0; i < ls; i++) fail[i]++;
int ans[lt + 5], ind = 0;
while(currentInd < lt){
if(s[matched] != t[currentInd]){
if(!matched) currentInd++;
else {
matched = fail[matched - 1];
}
} else {
matched++;
currentInd++;
if(matched == ls){
ans[ind++] = currentInd - matched;
matched = fail[matched - 1];
}
}
}
if(!ind) cout << endl;
for(int i = 0; i < ind; i++) cout << ans[i] << " \n"[i == ind-1];
}
/*
#include <iostream>
#include <string.h>
#define int long long int
using namespace std;
string s, t;
const int maxN = 5e5, b = 10, p = 1e9 + 7;
int exp(int b, int e){
if(e == 1) return b;
int res = exp(b, e/2);
res = res * res % p;
if(e % 2) res = res * e % p;
return res;
}
signed main(){
cin >> s >> t;
//get hash of t
int hashT[t.length()], ans[t.length()], ind = 0;
int inv = exp(b, s.length() - 2);
int hashVals[t.length() + 5], hashS = 0;
for(int i = 0; i < s.length(); i++){
hashS = (hashS * b + p) % p + (s[i] - 'a' + 1);
}
hashVals[0] = 0;
for(int i = 1; i <= t.length(); i++){
hashVals[i] = (hashVals[i-1]*b + (t[i] - 'a' + 1)) % p;
}
for(int i = s.length(); i <= t.length(); i++){
//cout << "Roll: " << ((hashVals[i] - hashVals[i - s.length()] * exp(b, s.length())) * exp(inv, s.length())) << endl;
if(hashS == ((hashVals[i] - hashVals[i - s.length()] * exp(b, s.length())) * exp(inv, s.length()))) ans[ind++] = i - s.length();
}
if(!ind) cout << endl;
for(int i = 0; i < ind; i++) cout << ans[i] << " \n"[i == ind - 1];
}
*/
| [
"zhxnliu@gmail.com"
] | zhxnliu@gmail.com |
3d50ddb280505450ac7eb5404c27d93e1060e9b9 | 1334014eaeffdde4886da49ce5f387c46a5cc23a | /2020-2/DataStructure/BTS/BTS.cpp | a0af05ce830b7cff9550be33206a5c55db3adbef | [] | no_license | gusah009/Algorithm | a85b1a4526a885b1f809c23c55565f453a5294c4 | 5da952e16a6f90f663706675812f042707aa7280 | refs/heads/main | 2023-07-31T17:28:20.404630 | 2021-09-05T06:14:00 | 2021-09-05T06:14:00 | 357,753,076 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,775 | cpp | #include <iostream>
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, j) for(int i = 0; i < j; i++)
#define L node->left
#define R node->right
int N, depth;
string state, name;
bool exist;
typedef struct tree{
tree* left;
tree* right;
string name;
} Tree;
void insertNode(Tree* node)
{
if (node->name == "") {
node->name = name;
L = new Tree;
R = new Tree;
} else {
if (name < node->name) {
insertNode(L);
} else {
insertNode(R);
}
}
}
Tree* findNode(Tree* root)
{
Tree* node;
if (root->name == name) {
return root;
} else {
if (root->left->name != "") {
node = findNode(root->left);
if (node != nullptr) return node;
}
if (root->right->name != "") {
node = findNode(root->right);
if (node != nullptr) return node;
}
}
return nullptr;
}
bool isLeaf(Tree* node)
{
if (L->name == "" && R->name == "") {
return true;
}
return false;
}
string deleteNode(Tree* node, Tree* parent, char dir)
{
if (dir == 'L') {
if (R->name == "") {
string ret = node->name;
if (parent->name == name) parent->left = L;
else parent->right = L;
delete node;
return ret;
}
return deleteNode(R, node, 'L');
} else {
if (L->name == "") {
string ret = node->name;
if (parent->name == name) parent->right = R;
else parent->left = R;
delete node;
return ret;
}
return deleteNode(L, node, 'R');
}
}
void printNode(int depth, Tree* node)
{
if (node->name == "") {
return;
}
if (depth == 1) {
exist = false;
cout << node->name << " ";
return;
}
printNode(depth - 1, L);
printNode(depth - 1, R);
}
void printLeaf(Tree* node)
{
if (node->name == "") {
return;
}
if (isLeaf(node)) {
cout << node->name << " ";
return;
}
printLeaf(L);
printLeaf(R);
}
void input_solve()
{
cin >> N;
Tree* root = new Tree;
root->left = new Tree;
root->right = new Tree;
FOR(n, N) {
cin >> state;
if (state == "+") {
cin >> name;
insertNode(root);
} else if (state == "-") {
cin >> name;
Tree* node = findNode(root);
if (node != nullptr) {
if (isLeaf(node)) {
node->name = "";
delete L;
delete R;
} else {
if (L->name != "") {
node->name = deleteNode(L, node, 'L');
} else {
node->name = deleteNode(R, node, 'R');
}
}
}
} else if (state == "depth") {
cin >> depth;
exist = true;
printNode(depth, root);
if (exist) cout << "NO\n";
else cout << "\n";
} else {
printLeaf(root);
cout << "\n";
}
}
}
int main()
{
input_solve();
} | [
"minion@bmeks.co.kr"
] | minion@bmeks.co.kr |
d85e66ecc87239e2c0f34ad3de5263bb803f24a9 | 0c667e9d5af64319d21780cce0a13ca186b31ad8 | /109_(有序链表转换为二叉搜索树)Convert Sorted List to Binary Search Tree/109_(有序链表转换为二叉搜索树)Convert Sorted List to Binary Search Tree.cpp | 4f5c0bf740e231f5fe9b4c2727c4537084eaa605 | [] | no_license | Longerhaha/Leetcode_Cpp | f6248f559ce37bef8fb2b6ef3dab7b753dd00c9b | 301196282f86b023f9549be08fcdcc45503649a6 | refs/heads/master | 2021-07-12T08:37:14.541975 | 2019-01-09T06:15:40 | 2019-01-09T06:15:40 | 146,104,579 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,404 | cpp | /**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
/**
* 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:
//函数中涉及到的指针操作
//head 为 ListNode* 类型的指针， head->val 是这个指针所指向的节点的值
//head->next 为 head 所指向的节点的下一个节点的指针
//TreeNode* root = new TreeNode(val) 返回从堆中生成一个值为 val 的链表节点的指针给root
//root->left 是 root 所指向节点的左子树的指针, root->right 同理
//解题思路
//1.快慢指针分离成左子树所有节点构成的链表、根节点和右子树所有节点构成的链表
//2.根据根节点递归分离的两个链表，第一个链表为左子树，第二个链表为右子树
TreeNode* sortedListToBST(ListNode* head) {
//边界情况:链表为空或者只有一个节点
if(head == nullptr) return nullptr;
if(head->next == nullptr) return new TreeNode(head->val);
//1.快慢指针分离成根节点、左子树所有节点构成的链表和右子树所有节点构成的链表
//slow为二叉搜索树左子树所有节点构成的链表的链表的尾巴，其链表头为head
//slow->next->val为二叉搜索树根节点的值
//slow->next->next为二叉搜索树右子树所有节点构成的链表的头节点指针
ListNode *slow = head, *fast = head->next;
while( fast != nullptr ){
fast = fast->next == nullptr ? nullptr : fast->next->next;
slow = fast == nullptr ? slow : slow->next;
}
//2. 根据根节点递归分离的两个链表，第一个链表为左子树，第二个链表为右子树
TreeNode* root = new TreeNode(slow->next->val);
slow->next = nullptr;//分离第一个链表
ListNode* list2head = slow->next->next;//获取第二个链表的头节点指针
//递归构造二叉搜索树
root->left = sortedListToBST(head);
root->right = sortedListToBST(list2head);
return root;
}
}; | [
"longerhaha@outlook.com"
] | longerhaha@outlook.com |
5ac9231547a4256df55e40347f8b43e2db4c8bf0 | 21553f6afd6b81ae8403549467230cdc378f32c9 | /arm/cortex/Freescale/MK20D10/include/arch/reg/axbs.hpp | a93e4a688d72f79d6a22de9c29afef30b073d641 | [] | no_license | digint/openmptl-reg-arm-cortex | 3246b68dcb60d4f7c95a46423563cab68cb02b5e | 88e105766edc9299348ccc8d2ff7a9c34cddacd3 | refs/heads/master | 2021-07-18T19:56:42.569685 | 2017-10-26T11:11:35 | 2017-10-26T11:11:35 | 108,407,162 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,427 | hpp | /*
* OpenMPTL - C++ Microprocessor Template Library
*
* This program is a derivative representation of a CMSIS System View
* Description (SVD) file, and is subject to the corresponding license
* (see "Freescale CMSIS-SVD License Agreement.pdf" in the parent directory).
*
* 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.
*/
////////////////////////////////////////////////////////////////////////
//
// Import from CMSIS-SVD: "Freescale/MK20D10.svd"
//
// vendor: Freescale Semiconductor, Inc.
// vendorID: Freescale
// name: MK20D10
// series: Kinetis_K
// version: 1.6
// description: MK20D10 Freescale Microcontroller
// --------------------------------------------------------------------
//
// C++ Header file, containing architecture specific register
// declarations for use in OpenMPTL. It has been converted directly
// from a CMSIS-SVD file.
//
// https://digint.ch/openmptl
// https://github.com/posborne/cmsis-svd
//
#ifndef ARCH_REG_AXBS_HPP_INCLUDED
#define ARCH_REG_AXBS_HPP_INCLUDED
#warning "using untested register declarations"
#include <register.hpp>
namespace mptl {
/**
* Crossbar switch
*/
struct AXBS
{
static constexpr reg_addr_t base_addr = 0x40004000;
/**
* Priority Registers Slave
*/
struct PRS%s
: public reg< uint32_t, base_addr + 0, rw, 0x543210 >
{
using type = reg< uint32_t, base_addr + 0, rw, 0x543210 >;
using M0 = regbits< type, 0, 3 >; /**< Master 0 Priority. Sets the arbitration priority for this port on the associated slave port. */
using M1 = regbits< type, 4, 3 >; /**< Master 1 Priority. Sets the arbitration priority for this port on the associated slave port. */
using M2 = regbits< type, 8, 3 >; /**< Master 2 Priority. Sets the arbitration priority for this port on the associated slave port. */
using M3 = regbits< type, 12, 3 >; /**< Master 3 Priority. Sets the arbitration priority for this port on the associated slave port. */
using M4 = regbits< type, 16, 3 >; /**< Master 4 Priority. Sets the arbitration priority for this port on the associated slave port. */
using M5 = regbits< type, 20, 3 >; /**< Master 5 Priority. Sets the arbitration priority for this port on the associated slave port. */
};
/**
* Control Register
*/
struct CRS%s
: public reg< uint32_t, base_addr + 0x10, rw, 0 >
{
using type = reg< uint32_t, base_addr + 0x10, rw, 0 >;
using PARK = regbits< type, 0, 3 >; /**< Park */
using PCTL = regbits< type, 4, 2 >; /**< Parking Control */
using ARB = regbits< type, 8, 2 >; /**< Arbitration Mode */
using HLP = regbits< type, 30, 1 >; /**< Halt Low Priority */
using RO = regbits< type, 31, 1 >; /**< Read Only */
};
/**
* Master General Purpose Control Register
*/
struct MGPCR0
: public reg< uint32_t, base_addr + 0x800, rw, 0 >
{
using type = reg< uint32_t, base_addr + 0x800, rw, 0 >;
using AULB = regbits< type, 0, 3 >; /**< Arbitrates On Undefined Length Bursts */
};
/**
* Master General Purpose Control Register
*/
struct MGPCR1
: public reg< uint32_t, base_addr + 0x900, rw, 0 >
{
using type = reg< uint32_t, base_addr + 0x900, rw, 0 >;
using AULB = regbits< type, 0, 3 >; /**< Arbitrates On Undefined Length Bursts */
};
/**
* Master General Purpose Control Register
*/
struct MGPCR2
: public reg< uint32_t, base_addr + 0xa00, rw, 0 >
{
using type = reg< uint32_t, base_addr + 0xa00, rw, 0 >;
using AULB = regbits< type, 0, 3 >; /**< Arbitrates On Undefined Length Bursts */
};
/**
* Master General Purpose Control Register
*/
struct MGPCR4
: public reg< uint32_t, base_addr + 0xc00, rw, 0 >
{
using type = reg< uint32_t, base_addr + 0xc00, rw, 0 >;
using AULB = regbits< type, 0, 3 >; /**< Arbitrates On Undefined Length Bursts */
};
/**
* Master General Purpose Control Register
*/
struct MGPCR5
: public reg< uint32_t, base_addr + 0xd00, rw, 0 >
{
using type = reg< uint32_t, base_addr + 0xd00, rw, 0 >;
using AULB = regbits< type, 0, 3 >; /**< Arbitrates On Undefined Length Bursts */
};
};
} // namespace mptl
#endif // ARCH_REG_AXBS_HPP_INCLUDED
| [
"axel@tty0.ch"
] | axel@tty0.ch |
32d2a12bb12e4a453ee743676467efb1841f2c8d | 8a62c13b40a2c05f2650f7e1585a262f70726273 | /Headers/choose.h | f44e9148b2d47d0f25bca7825fb3d62f01cfab14 | [] | no_license | Leslie5205912/Book_Manage_System | 226e1ae767d88fca2b1ae5108189181ac8047838 | 91a5505f43f76a8aa492dff6c47ddb27edaf70db | refs/heads/master | 2020-04-25T14:39:22.022084 | 2019-02-27T05:49:49 | 2019-02-27T05:49:49 | 172,848,807 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 455 | h | #ifndef CHOOSE_H
#define CHOOSE_H
#include <QDialog>
#include<insert.h>
#include<book_delete.h>
namespace Ui {
class Choose;
}
class Choose : public QDialog
{
Q_OBJECT
public:
explicit Choose(QWidget *parent = nullptr);
~Choose();
private slots:
void on_pushButton_clicked();
void on_pushButton_2_clicked();
private:
Ui::Choose *ui;
Insert *ist;
Book_Delete *dlt;
};
#endif // CHOOSE_H
| [
"noreply@github.com"
] | noreply@github.com |
311130c789cb0ce9a5546c28a107ca21e395c28e | a9fe3022423f50a8eb6e37e5a4c636c40f8d04fb | /deps/fdk-aac/libSACdec/src/sac_dec.cpp | a7b50df4452ae198868c032c73e55024b8935743 | [
"LicenseRef-scancode-warranty-disclaimer",
"FDK-AAC",
"LicenseRef-scancode-other-permissive",
"MIT"
] | permissive | toyobayashi/mishiro-core | f4f8601ca574abea4d27e68efb0c9fe60274403a | e10229b24733444f5cfc3b2b2a05256f0697b92e | refs/heads/master | 2021-11-25T13:29:42.630212 | 2021-11-01T08:14:53 | 2021-11-01T08:14:53 | 128,219,004 | 10 | 2 | MIT | 2020-06-17T09:42:59 | 2018-04-05T14:35:48 | JavaScript | UTF-8 | C++ | false | false | 55,612 | cpp | /* -----------------------------------------------------------------------------
Software License for The Fraunhofer FDK AAC Codec Library for Android
© Copyright 1995 - 2019 Fraunhofer-Gesellschaft zur Förderung der angewandten
Forschung e.V. All rights reserved.
1. INTRODUCTION
The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
scheme for digital audio. This FDK AAC Codec software is intended to be used on
a wide variety of Android devices.
AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
general perceptual audio codecs. AAC-ELD is considered the best-performing
full-bandwidth communications codec by independent studies and is widely
deployed. AAC has been standardized by ISO and IEC as part of the MPEG
specifications.
Patent licenses for necessary patent claims for the FDK AAC Codec (including
those of Fraunhofer) may be obtained through Via Licensing
(www.vialicensing.com) or through the respective patent owners individually for
the purpose of encoding or decoding bit streams in products that are compliant
with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
Android devices already license these patent claims through Via Licensing or
directly from the patent owners, and therefore FDK AAC Codec software may
already be covered under those patent licenses when it is used for those
licensed purposes only.
Commercially-licensed AAC software libraries, including floating-point versions
with enhanced sound quality, are also available from Fraunhofer. Users are
encouraged to check the Fraunhofer website for additional applications
information and documentation.
2. COPYRIGHT LICENSE
Redistribution and use in source and binary forms, with or without modification,
are permitted without payment of copyright license fees provided that you
satisfy the following conditions:
You must retain the complete text of this software license in redistributions of
the FDK AAC Codec or your modifications thereto in source code form.
You must retain the complete text of this software license in the documentation
and/or other materials provided with redistributions of the FDK AAC Codec or
your modifications thereto in binary form. You must make available free of
charge copies of the complete source code of the FDK AAC Codec and your
modifications thereto to recipients of copies in binary form.
The name of Fraunhofer may not be used to endorse or promote products derived
from this library without prior written permission.
You may not charge copyright license fees for anyone to use, copy or distribute
the FDK AAC Codec software or your modifications thereto.
Your modified versions of the FDK AAC Codec must carry prominent notices stating
that you changed the software and the date of any change. For modified versions
of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
AAC Codec Library for Android."
3. NO PATENT LICENSE
NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
Fraunhofer provides no warranty of patent non-infringement with respect to this
software.
You may use this FDK AAC Codec software or modifications thereto only for
purposes that are authorized by appropriate patent licenses.
4. DISCLAIMER
This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
including but not limited to the implied warranties of merchantability and
fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
or consequential damages, including but not limited to procurement of substitute
goods or services; loss of use, data, or profits, or business interruption,
however caused and on any theory of liability, whether in contract, strict
liability, or tort (including negligence), arising in any way out of the use of
this software, even if advised of the possibility of such damage.
5. CONTACT INFORMATION
Fraunhofer Institute for Integrated Circuits IIS
Attention: Audio and Multimedia Departments - FDK AAC LL
Am Wolfsmantel 33
91058 Erlangen, Germany
www.iis.fraunhofer.de/amm
amm-info@iis.fraunhofer.de
----------------------------------------------------------------------------- */
/*********************** MPEG surround decoder library *************************
Author(s):
Description: SAC Decoder Library
*******************************************************************************/
#include "sac_dec_errorcodes.h"
#include "sac_dec.h"
#include "sac_process.h"
#include "sac_bitdec.h"
#include "sac_smoothing.h"
#include "sac_calcM1andM2.h"
#include "sac_reshapeBBEnv.h"
#include "sac_stp.h"
#include "sac_rom.h"
#include "FDK_decorrelate.h"
#include "FDK_trigFcts.h"
#include "FDK_matrixCalloc.h"
/* static int pbStrideTable[] = {1, 2, 5, 28}; see sac_rom.cpp */
enum {
APPLY_M2_NONE = 0, /* init value */
APPLY_M2 = 1, /* apply m2 fallback implementation */
APPLY_M2_MODE212 = 2, /* apply m2 for 212 mode */
APPLY_M2_MODE212_Res_PhaseCoding =
3 /* apply m2 for 212 mode with residuals and phase coding */
};
/******************************************************************************************/
/* function: FDK_SpatialDecInitDefaultSpatialSpecificConfig */
/* output: struct of type SPATIAL_SPECIFIC_CONFIG */
/* input: core coder audio object type */
/* input: nr of core channels */
/* input: sampling rate */
/* input: nr of time slots */
/* input: decoder level */
/* input: flag indicating upmix type blind */
/* */
/* returns: error code */
/******************************************************************************************/
int FDK_SpatialDecInitDefaultSpatialSpecificConfig(
SPATIAL_SPECIFIC_CONFIG *pSpatialSpecificConfig,
AUDIO_OBJECT_TYPE coreCodec, int coreChannels, int samplingFreq,
int nTimeSlots, int decoderLevel, int isBlind) {
return SpatialDecDefaultSpecificConfig(pSpatialSpecificConfig, coreCodec,
samplingFreq, nTimeSlots, decoderLevel,
isBlind, coreChannels);
}
/******************************************************************************************/
/* function: FDK_SpatialDecCompareSpatialSpecificConfigHeader */
/* input: 2 pointers to a ssc */
/* */
/* output: - */
/* returns: error code (0 = equal, <>0 unequal) */
/******************************************************************************************/
int FDK_SpatialDecCompareSpatialSpecificConfigHeader(
SPATIAL_SPECIFIC_CONFIG *pSsc1, SPATIAL_SPECIFIC_CONFIG *pSsc2) {
int result = MPS_OK;
/* we assume: every bit must be equal */
if (FDKmemcmp(pSsc1, pSsc2, sizeof(SPATIAL_SPECIFIC_CONFIG)) != 0) {
result = MPS_UNEQUAL_SSC;
}
return result;
}
/*******************************************************************************
Functionname: SpatialDecClearFrameData
*******************************************************************************
Description: Clear/Fake frame data to avoid misconfiguration and allow proper
error concealment.
Arguments:
Input: self (frame data)
Output: No return value.
*******************************************************************************/
static void SpatialDecClearFrameData(
spatialDec *self, /* Shall be removed */
SPATIAL_BS_FRAME *bsFrame, const SACDEC_CREATION_PARAMS *const setup) {
int i;
FDK_ASSERT(self != NULL);
FDK_ASSERT(bsFrame != NULL);
FDK_ASSERT(setup != NULL);
/* do not apply shaping tools (GES or STP) */
for (i = 0; i < setup->maxNumOutputChannels;
i += 1) { /* MAX_OUTPUT_CHANNELS */
bsFrame->tempShapeEnableChannelSTP[i] = 0;
bsFrame->tempShapeEnableChannelGES[i] = 0;
}
bsFrame->TsdData->bsTsdEnable = 0;
/* use only 1 parameter set at the end of the frame */
bsFrame->numParameterSets = 1;
bsFrame->paramSlot[0] = self->timeSlots - 1;
/* parameter smoothing tool set to off */
bsFrame->bsSmoothMode[0] = 0;
initParameterSmoothing(self);
/* reset residual data */
{
int resQmfBands, resTimeSlots = (1);
resQmfBands = setup->maxNumQmfBands;
for (i = 0; i < setup->bProcResidual
? fMin(setup->maxNumResChannels,
setup->maxNumOttBoxes + setup->maxNumInputChannels)
: 0;
i += 1) {
for (int j = 0; j < resTimeSlots; j += 1) {
for (int k = 0; k < resQmfBands; k += 1) {
self->qmfResidualReal__FDK[i][j][k] = FL2FXCONST_DBL(0.0f);
self->qmfResidualImag__FDK[i][j][k] = FL2FXCONST_DBL(0.0f);
}
}
}
}
return;
}
/*******************************************************************************
Functionname: FDK_SpatialDecOpen
*******************************************************************************
Description:
Arguments:
Return:
*******************************************************************************/
spatialDec *FDK_SpatialDecOpen(const SPATIAL_DEC_CONFIG *config,
int stereoConfigIndex) {
int i;
int lfSize, hfSize;
spatialDec *self = NULL;
SACDEC_CREATION_PARAMS setup;
switch (config->decoderLevel) {
case DECODER_LEVEL_0: /* 212 maxNumOutputChannels== 2 */
setup.maxNumInputChannels = 1;
setup.maxNumOutputChannels = 2;
setup.maxNumQmfBands = 64;
setup.maxNumXChannels = 2;
setup.maxNumVChannels = 2;
setup.maxNumDecorChannels = 1;
setup.bProcResidual = 1;
setup.maxNumResidualChannels = 0;
setup.maxNumOttBoxes = 1;
setup.maxNumParams = setup.maxNumInputChannels + setup.maxNumOttBoxes;
break;
default:
return NULL;
}
setup.maxNumResChannels = 1;
{
switch (config->maxNumOutputChannels) {
case OUTPUT_CHANNELS_2_0:
setup.maxNumOutputChannels = fMin(setup.maxNumOutputChannels, 2);
break;
case OUTPUT_CHANNELS_DEFAULT:
default:
break;
}
}
setup.maxNumHybridBands = SacGetHybridSubbands(setup.maxNumQmfBands);
switch (config->decoderMode) {
case EXT_HQ_ONLY:
setup.maxNumCmplxQmfBands = setup.maxNumQmfBands;
setup.maxNumCmplxHybBands = setup.maxNumHybridBands;
break;
default:
setup.maxNumCmplxQmfBands = fixMax(PC_NUM_BANDS, setup.maxNumQmfBands);
setup.maxNumCmplxHybBands =
fixMax(PC_NUM_HYB_BANDS, setup.maxNumHybridBands);
break;
} /* switch config->decoderMode */
FDK_ALLOCATE_MEMORY_1D_INT(self, 1, spatialDec, SECT_DATA_L2)
self->createParams = setup;
FDK_ALLOCATE_MEMORY_1D(self->param2hyb, MAX_PARAMETER_BANDS + 1, int)
FDK_ALLOCATE_MEMORY_1D(self->numOttBands, setup.maxNumOttBoxes, int)
/* allocate arrays */
FDK_ALLOCATE_MEMORY_1D(self->smgTime, MAX_PARAMETER_SETS, int)
FDK_ALLOCATE_MEMORY_2D(self->smgData, MAX_PARAMETER_SETS, MAX_PARAMETER_BANDS,
UCHAR)
FDK_ALLOCATE_MEMORY_3D(self->ottCLD__FDK, setup.maxNumOttBoxes,
MAX_PARAMETER_SETS, MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_3D(self->ottICC__FDK, setup.maxNumOttBoxes,
MAX_PARAMETER_SETS, MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_3D(self->ottIPD__FDK, setup.maxNumOttBoxes,
MAX_PARAMETER_SETS, MAX_PARAMETER_BANDS, SCHAR)
/* Last parameters from prev frame */
FDK_ALLOCATE_MEMORY_2D(self->ottCLDidxPrev, setup.maxNumOttBoxes,
MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_2D(self->ottICCidxPrev, setup.maxNumOttBoxes,
MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_3D(self->ottICCdiffidx, setup.maxNumOttBoxes,
MAX_PARAMETER_SETS, MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_2D(self->ottIPDidxPrev, setup.maxNumOttBoxes,
MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_2D(self->arbdmxGainIdxPrev, setup.maxNumInputChannels,
MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_2D(self->cmpOttCLDidxPrev, setup.maxNumOttBoxes,
MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_2D(self->cmpOttICCidxPrev, setup.maxNumOttBoxes,
MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_3D(self->outIdxData, setup.maxNumOttBoxes,
MAX_PARAMETER_SETS, MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_3D(self->arbdmxGain__FDK, setup.maxNumInputChannels,
MAX_PARAMETER_SETS, MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_1D(self->arbdmxAlpha__FDK, setup.maxNumInputChannels,
FIXP_DBL)
FDK_ALLOCATE_MEMORY_1D(self->arbdmxAlphaPrev__FDK, setup.maxNumInputChannels,
FIXP_DBL)
FDK_ALLOCATE_MEMORY_2D(self->cmpArbdmxGainIdxPrev, setup.maxNumInputChannels,
MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_2D(self->cmpOttIPDidxPrev, setup.maxNumOttBoxes,
MAX_PARAMETER_BANDS, SCHAR)
FDK_ALLOCATE_MEMORY_3D_INT(self->M2Real__FDK, setup.maxNumOutputChannels,
setup.maxNumVChannels, MAX_PARAMETER_BANDS,
FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_3D(self->M2Imag__FDK, setup.maxNumOutputChannels,
setup.maxNumVChannels, MAX_PARAMETER_BANDS, FIXP_DBL)
FDK_ALLOCATE_MEMORY_3D_INT(self->M2RealPrev__FDK, setup.maxNumOutputChannels,
setup.maxNumVChannels, MAX_PARAMETER_BANDS,
FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_3D(self->M2ImagPrev__FDK, setup.maxNumOutputChannels,
setup.maxNumVChannels, MAX_PARAMETER_BANDS, FIXP_DBL)
FDK_ALLOCATE_MEMORY_2D_INT_ALIGNED(
self->qmfInputReal__FDK, setup.maxNumInputChannels, setup.maxNumQmfBands,
FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_2D_INT_ALIGNED(
self->qmfInputImag__FDK, setup.maxNumInputChannels,
setup.maxNumCmplxQmfBands, FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_2D_INT(self->hybInputReal__FDK, setup.maxNumInputChannels,
setup.maxNumHybridBands, FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_2D_INT(self->hybInputImag__FDK, setup.maxNumInputChannels,
setup.maxNumCmplxHybBands, FIXP_DBL, SECT_DATA_L2)
if (setup.bProcResidual) {
FDK_ALLOCATE_MEMORY_1D(self->qmfResidualReal__FDK, setup.maxNumResChannels,
FIXP_DBL **)
FDK_ALLOCATE_MEMORY_1D(self->qmfResidualImag__FDK, setup.maxNumResChannels,
FIXP_DBL **)
FDK_ALLOCATE_MEMORY_1D(self->hybResidualReal__FDK, setup.maxNumResChannels,
FIXP_DBL *)
FDK_ALLOCATE_MEMORY_1D(self->hybResidualImag__FDK, setup.maxNumResChannels,
FIXP_DBL *)
for (i = 0; i < setup.maxNumResChannels; i++) {
int resQmfBands = (config->decoderMode == EXT_LP_ONLY)
? PC_NUM_BANDS
: setup.maxNumQmfBands;
int resHybBands = (config->decoderMode == EXT_LP_ONLY)
? PC_NUM_HYB_BANDS
: setup.maxNumHybridBands;
/* Alignment is needed for USAC residuals because QMF analysis directly
* writes to this buffer. */
FDK_ALLOCATE_MEMORY_2D_INT_ALIGNED(self->qmfResidualReal__FDK[i], (1),
resQmfBands, FIXP_DBL, SECT_DATA_L1)
FDK_ALLOCATE_MEMORY_2D_INT_ALIGNED(self->qmfResidualImag__FDK[i], (1),
resQmfBands, FIXP_DBL, SECT_DATA_L1)
FDK_ALLOCATE_MEMORY_1D(self->hybResidualReal__FDK[i],
setup.maxNumHybridBands, FIXP_DBL)
FDK_ALLOCATE_MEMORY_1D(self->hybResidualImag__FDK[i], resHybBands,
FIXP_DBL)
}
} /* if (setup.bProcResidual) */
FDK_ALLOCATE_MEMORY_2D_INT(self->wReal__FDK, setup.maxNumVChannels,
setup.maxNumHybridBands, FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_2D_INT(self->wImag__FDK, setup.maxNumVChannels,
setup.maxNumCmplxHybBands, FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_2D_INT(self->hybOutputRealDry__FDK,
setup.maxNumOutputChannels,
setup.maxNumHybridBands, FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_2D_INT(self->hybOutputImagDry__FDK,
setup.maxNumOutputChannels,
setup.maxNumCmplxHybBands, FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_2D_INT(self->hybOutputRealWet__FDK,
setup.maxNumOutputChannels,
setup.maxNumHybridBands, FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_2D_INT(self->hybOutputImagWet__FDK,
setup.maxNumOutputChannels,
setup.maxNumCmplxHybBands, FIXP_DBL, SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_1D(self->hybridSynthesis, setup.maxNumOutputChannels,
FDK_SYN_HYB_FILTER)
FDK_ALLOCATE_MEMORY_1D(
self->hybridAnalysis,
setup.bProcResidual ? setup.maxNumInputChannels + setup.maxNumResChannels
: setup.maxNumInputChannels,
FDK_ANA_HYB_FILTER)
lfSize = 2 * BUFFER_LEN_LF * MAX_QMF_BANDS_TO_HYBRID;
{
hfSize =
BUFFER_LEN_HF * ((setup.maxNumQmfBands - MAX_QMF_BANDS_TO_HYBRID) +
(setup.maxNumCmplxQmfBands - MAX_QMF_BANDS_TO_HYBRID));
}
FDK_ALLOCATE_MEMORY_2D_INT(self->pHybridAnaStatesLFdmx,
setup.maxNumInputChannels, lfSize, FIXP_DBL,
SECT_DATA_L2) {
FDK_ALLOCATE_MEMORY_2D(self->pHybridAnaStatesHFdmx,
setup.maxNumInputChannels, hfSize, FIXP_DBL)
}
for (i = 0; i < setup.maxNumInputChannels; i++) {
FIXP_DBL *pHybridAnaStatesHFdmx;
pHybridAnaStatesHFdmx = self->pHybridAnaStatesHFdmx[i];
FDKhybridAnalysisOpen(&self->hybridAnalysis[i],
self->pHybridAnaStatesLFdmx[i],
lfSize * sizeof(FIXP_DBL), pHybridAnaStatesHFdmx,
hfSize * sizeof(FIXP_DBL));
}
if (setup.bProcResidual) {
lfSize = 2 * BUFFER_LEN_LF * MAX_QMF_BANDS_TO_HYBRID;
hfSize = BUFFER_LEN_HF *
((((config->decoderMode == EXT_LP_ONLY) ? PC_NUM_BANDS
: setup.maxNumQmfBands) -
MAX_QMF_BANDS_TO_HYBRID) +
(setup.maxNumCmplxQmfBands - MAX_QMF_BANDS_TO_HYBRID));
FDK_ALLOCATE_MEMORY_2D_INT(self->pHybridAnaStatesLFres,
setup.maxNumResChannels, lfSize, FIXP_DBL,
SECT_DATA_L2)
FDK_ALLOCATE_MEMORY_2D(self->pHybridAnaStatesHFres, setup.maxNumResChannels,
hfSize, FIXP_DBL)
for (i = setup.maxNumInputChannels;
i < (setup.maxNumInputChannels + setup.maxNumResChannels); i++) {
FDKhybridAnalysisOpen(
&self->hybridAnalysis[i],
self->pHybridAnaStatesLFres[i - setup.maxNumInputChannels],
lfSize * sizeof(FIXP_DBL),
self->pHybridAnaStatesHFres[i - setup.maxNumInputChannels],
hfSize * sizeof(FIXP_DBL));
}
}
FDK_ALLOCATE_MEMORY_1D(self->smoothState, 1, SMOOTHING_STATE)
FDK_ALLOCATE_MEMORY_1D(self->reshapeBBEnvState, 1, RESHAPE_BBENV_STATE)
FDK_ALLOCATE_MEMORY_1D(self->apDecor, setup.maxNumDecorChannels, DECORR_DEC)
FDK_ALLOCATE_MEMORY_2D_INT(self->pDecorBufferCplx, setup.maxNumDecorChannels,
(2 * ((825) + (373))), FIXP_DBL, SECT_DATA_L2)
for (i = 0; i < setup.maxNumDecorChannels; i++) {
if (FDKdecorrelateOpen(&self->apDecor[i], self->pDecorBufferCplx[i],
(2 * ((825) + (373))))) {
goto bail;
}
}
if (subbandTPCreate(&self->hStpDec) != MPS_OK) {
goto bail;
}
/* save general decoder configuration */
self->decoderLevel = config->decoderLevel;
self->decoderMode = config->decoderMode;
self->binauralMode = config->binauralMode;
/* preinitialize configuration */
self->partiallyComplex = (config->decoderMode != EXT_HQ_ONLY) ? 1 : 0;
/* Set to default state */
SpatialDecConcealment_Init(&self->concealInfo, MPEGS_CONCEAL_RESET_ALL);
/* Everything is fine so return the handle */
return self;
bail:
/* Collector for all errors.
Deallocate all memory and return a invalid handle. */
FDK_SpatialDecClose(self);
return NULL;
}
/*******************************************************************************
Functionname: isValidConfig
*******************************************************************************
Description: Validate if configuration is supported in present instance
Arguments:
Return: 1: all okay
0: configuration not supported
*******************************************************************************/
static int isValidConfig(spatialDec const *const self,
const SPATIAL_DEC_UPMIX_TYPE upmixType,
SPATIALDEC_PARAM const *const pUserParams,
const AUDIO_OBJECT_TYPE coreAot) {
UPMIXTYPE nUpmixType;
FDK_ASSERT(self != NULL);
FDK_ASSERT(pUserParams != NULL);
nUpmixType = (UPMIXTYPE)upmixType;
switch (nUpmixType) {
case UPMIXTYPE_BYPASS: /* UPMIX_TYPE_BYPASS */
break;
case UPMIXTYPE_NORMAL: /* UPMIX_TYPE_NORMAL */
break;
default:
return 0; /* unsupported upmixType */
}
return 1; /* upmixType supported */
}
static SACDEC_ERROR CheckLevelTreeUpmixType(
const SACDEC_CREATION_PARAMS *const pCreateParams,
const SPATIAL_SPECIFIC_CONFIG *const pSsc, const int decoderLevel,
const UPMIXTYPE upmixType) {
SACDEC_ERROR err = MPS_OK;
int nOutputChannels, treeConfig;
FDK_ASSERT(pCreateParams != NULL);
FDK_ASSERT(pSsc != NULL);
treeConfig = pSsc->treeConfig;
switch (decoderLevel) {
case 0: {
if (treeConfig != SPATIALDEC_MODE_RSVD7) {
err = MPS_INVALID_TREECONFIG;
goto bail;
}
break;
}
default:
err = MPS_INVALID_PARAMETER /* MPS_UNIMPLEMENTED */;
goto bail;
}
switch (upmixType) {
case UPMIXTYPE_BYPASS:
nOutputChannels = pSsc->nInputChannels;
break;
default:
nOutputChannels = pSsc->nOutputChannels;
break;
}
/* Is sufficient memory allocated. */
if ((pSsc->nInputChannels > pCreateParams->maxNumInputChannels) ||
(nOutputChannels > pCreateParams->maxNumOutputChannels) ||
(pSsc->nOttBoxes > pCreateParams->maxNumOttBoxes)) {
err = MPS_INVALID_PARAMETER;
}
bail:
return err;
}
void SpatialDecInitParserContext(spatialDec *self) {
int i, j;
for (i = 0; i < self->createParams.maxNumOttBoxes; i += 1) {
for (j = 0; j < MAX_PARAMETER_BANDS; j++) {
self->ottCLDidxPrev[i][j] = 0;
self->ottICCidxPrev[i][j] = 0;
self->cmpOttCLDidxPrev[i][j] = 0;
self->cmpOttICCidxPrev[i][j] = 0;
}
}
for (i = 0; i < self->createParams.maxNumInputChannels; i++) {
for (j = 0; j < MAX_PARAMETER_BANDS; j++) {
self->arbdmxGainIdxPrev[i][j] = 0;
self->cmpArbdmxGainIdxPrev[i][j] = 0;
}
}
}
/*******************************************************************************
Functionname: FDK_SpatialDecInit
*******************************************************************************
Description:
Arguments:
Return:
*******************************************************************************/
SACDEC_ERROR FDK_SpatialDecInit(spatialDec *self, SPATIAL_BS_FRAME *frame,
SPATIAL_SPECIFIC_CONFIG *pSpatialSpecificConfig,
int nQmfBands,
SPATIAL_DEC_UPMIX_TYPE const upmixType,
SPATIALDEC_PARAM *pUserParams, UINT initFlags) {
SACDEC_ERROR err = MPS_OK;
int nCh, i, j, k;
int maxQmfBands;
int bypassMode = 0;
self->useFDreverb = 0;
/* check configuration parameter */
if (!isValidConfig(self, upmixType, pUserParams,
pSpatialSpecificConfig->coreCodec)) {
return MPS_INVALID_PARAMETER;
}
/* check tree configuration */
err = CheckLevelTreeUpmixType(&self->createParams, pSpatialSpecificConfig,
self->decoderLevel, (UPMIXTYPE)upmixType);
if (err != MPS_OK) {
goto bail;
}
/* Store and update instance after all checks passed successfully: */
self->upmixType = (UPMIXTYPE)upmixType;
if (initFlags & MPEGS_INIT_PARAMS_ERROR_CONCEALMENT) { /* At least one error
concealment
parameter changed */
err = SpatialDecConcealment_SetParam(
&self->concealInfo, SAC_DEC_CONCEAL_METHOD, pUserParams->concealMethod);
if (err != MPS_OK) {
goto bail;
}
err = SpatialDecConcealment_SetParam(&self->concealInfo,
SAC_DEC_CONCEAL_NUM_KEEP_FRAMES,
pUserParams->concealNumKeepFrames);
if (err != MPS_OK) {
goto bail;
}
err = SpatialDecConcealment_SetParam(
&self->concealInfo, SAC_DEC_CONCEAL_FADE_OUT_SLOPE_LENGTH,
pUserParams->concealFadeOutSlopeLength);
if (err != MPS_OK) {
goto bail;
}
err = SpatialDecConcealment_SetParam(&self->concealInfo,
SAC_DEC_CONCEAL_FADE_IN_SLOPE_LENGTH,
pUserParams->concealFadeInSlopeLength);
if (err != MPS_OK) {
goto bail;
}
err = SpatialDecConcealment_SetParam(&self->concealInfo,
SAC_DEC_CONCEAL_NUM_RELEASE_FRAMES,
pUserParams->concealNumReleaseFrames);
if (err != MPS_OK) {
goto bail;
}
}
if (initFlags &
MPEGS_INIT_STATES_ERROR_CONCEALMENT) { /* Set to default state */
SpatialDecConcealment_Init(&self->concealInfo, MPEGS_CONCEAL_RESET_STATE);
}
/* determine bypass mode */
bypassMode |= pUserParams->bypassMode;
bypassMode |= ((self->upmixType == UPMIXTYPE_BYPASS) ? 1 : 0);
/* static decoder scale depends on number of qmf bands */
switch (nQmfBands) {
case 16:
case 24:
case 32:
self->staticDecScale = 21;
break;
case 64:
self->staticDecScale = 22;
break;
default:
return MPS_INVALID_PARAMETER;
}
self->numParameterSetsPrev = 1;
self->qmfBands = nQmfBands;
/* self->hybridBands will be updated in SpatialDecDecodeHeader() below. */
self->bShareDelayWithSBR = 0;
err = SpatialDecDecodeHeader(self, pSpatialSpecificConfig);
if (err != MPS_OK) {
goto bail;
}
self->stereoConfigIndex = pSpatialSpecificConfig->stereoConfigIndex;
if (initFlags & MPEGS_INIT_STATES_ANA_QMF_FILTER) {
self->qmfInputDelayBufPos = 0;
self->pc_filterdelay = 1; /* Division by 0 not possible */
}
maxQmfBands = self->qmfBands;
/* init residual decoder */
/* init tonality smoothing */
if (initFlags & MPEGS_INIT_STATES_PARAM) {
initParameterSmoothing(self);
}
/* init GES */
initBBEnv(self, (initFlags & MPEGS_INIT_STATES_GES) ? 1 : 0);
/* Clip protection is applied only for normal processing. */
if (!isTwoChMode(self->upmixType) && !bypassMode) {
self->staticDecScale += self->clipProtectGainSF__FDK;
}
{
UINT flags = 0;
INT initStatesFlag = (initFlags & MPEGS_INIT_STATES_ANA_QMF_FILTER) ? 1 : 0;
INT useLdFilter =
(self->pConfigCurrent->syntaxFlags & SACDEC_SYNTAX_LD) ? 1 : 0;
flags = self->pQmfDomain->globalConf.flags_requested;
flags &= (~(UINT)QMF_FLAG_LP);
if (initStatesFlag)
flags &= ~QMF_FLAG_KEEP_STATES;
else
flags |= QMF_FLAG_KEEP_STATES;
if (useLdFilter)
flags |= QMF_FLAG_MPSLDFB;
else
flags &= ~QMF_FLAG_MPSLDFB;
self->pQmfDomain->globalConf.flags_requested = flags;
FDK_QmfDomain_Configure(self->pQmfDomain);
/* output scaling */
for (nCh = 0; nCh < self->numOutputChannelsAT; nCh++) {
int outputScale = 0, outputGain_e = 0, scale = -(8) + (1);
FIXP_DBL outputGain_m = getChGain(self, nCh, &outputGain_e);
if (!isTwoChMode(self->upmixType) && !bypassMode) {
outputScale +=
self->clipProtectGainSF__FDK; /* consider clip protection scaling at
synthesis qmf */
}
scale += outputScale;
qmfChangeOutScalefactor(&self->pQmfDomain->QmfDomainOut[nCh].fb, scale);
qmfChangeOutGain(&self->pQmfDomain->QmfDomainOut[nCh].fb, outputGain_m,
outputGain_e);
}
}
for (nCh = 0; nCh < self->numOutputChannelsAT; nCh++) {
FDKhybridSynthesisInit(&self->hybridSynthesis[nCh], THREE_TO_TEN,
self->qmfBands, maxQmfBands);
}
/* for input, residual channels and arbitrary down-mix residual channels */
for (nCh = 0; nCh < self->createParams.maxNumInputChannels; nCh++) {
FDKhybridAnalysisInit(
&self->hybridAnalysis[nCh], THREE_TO_TEN, self->qmfBands, maxQmfBands,
(initFlags & MPEGS_INIT_STATES_ANA_HYB_FILTER) ? 1 : 0);
}
for (; nCh < (self->createParams.bProcResidual
? (self->createParams.maxNumInputChannels +
self->createParams.maxNumResChannels)
: self->createParams.maxNumInputChannels);
nCh++) {
FDKhybridAnalysisInit(&self->hybridAnalysis[nCh], THREE_TO_TEN, maxQmfBands,
maxQmfBands, 0);
}
{
for (k = 0; k < self->numDecorSignals; k++) {
int errCode, idec;
FDK_DECORR_TYPE decorrType = DECORR_PS;
decorrType = DECORR_LD;
if (self->pConfigCurrent->syntaxFlags &
(SACDEC_SYNTAX_USAC | SACDEC_SYNTAX_RSVD50)) {
decorrType =
((self->treeConfig == TREE_212) && (self->decorrType == DECORR_PS))
? DECORR_PS
: DECORR_USAC;
}
{
idec = k;
if (self->pConfigCurrent->syntaxFlags & SACDEC_SYNTAX_LD) {
if (self->treeConfig == TREE_212 && k == 0) {
idec = 2;
}
}
}
errCode = FDKdecorrelateInit(
&self->apDecor[k], self->hybridBands, decorrType, DUCKER_AUTOMATIC,
self->decorrConfig, idec, 0, /* self->partiallyComplex */
0, 0, /* isLegacyPS */
(initFlags & MPEGS_INIT_STATES_DECORRELATOR) ? 1 : 0);
if (errCode) return MPS_NOTOK;
}
} /* !self->partiallyComplex */
err = initM1andM2(self, (initFlags & MPEGS_INIT_STATES_M1M2) ? 1 : 0,
(initFlags & MPEGS_INIT_CONFIG) ? 1 : 0);
if (err != MPS_OK) return err;
/* Initialization of previous frame data */
if (initFlags & MPEGS_INIT_STATES_PARAM) {
for (i = 0; i < self->createParams.maxNumOttBoxes; i += 1) {
/* reset icc diff data */
for (k = 0; k < MAX_PARAMETER_SETS; k += 1) {
for (j = 0; j < MAX_PARAMETER_BANDS; j += 1) {
self->ottICCdiffidx[i][k][j] = 0;
}
}
}
/* Parameter Smoothing */
/* robustness: init with one of the values of smgTimeTable[] = {64, 128,
256, 512} to avoid division by zero in calcFilterCoeff__FDK() */
self->smoothState->prevSmgTime = smgTimeTable[2]; /* == 256 */
FDKmemclear(self->smoothState->prevSmgData,
MAX_PARAMETER_BANDS * sizeof(UCHAR));
FDKmemclear(self->smoothState->opdLeftState__FDK,
MAX_PARAMETER_BANDS * sizeof(FIXP_DBL));
FDKmemclear(self->smoothState->opdRightState__FDK,
MAX_PARAMETER_BANDS * sizeof(FIXP_DBL));
}
self->prevTimeSlot = -1;
self->curTimeSlot =
MAX_TIME_SLOTS + 1; /* Initialize with a invalid value to trigger
concealment if first frame has no valid data. */
self->curPs = 0;
subbandTPInit(self->hStpDec);
bail:
return err;
}
void SpatialDecChannelProperties(spatialDec *self,
AUDIO_CHANNEL_TYPE channelType[],
UCHAR channelIndices[],
const FDK_channelMapDescr *const mapDescr) {
if ((self == NULL) || (channelType == NULL) || (channelIndices == NULL) ||
(mapDescr == NULL)) {
return; /* no extern buffer to be filled */
}
if (self->numOutputChannelsAT !=
treePropertyTable[self->treeConfig].numOutputChannels) {
int ch;
/* Declare all channels to be front channels: */
for (ch = 0; ch < self->numOutputChannelsAT; ch += 1) {
channelType[ch] = ACT_FRONT;
channelIndices[ch] = ch;
}
} else {
/* ISO/IEC FDIS 23003-1:2006(E), page 46, Table 40 bsTreeConfig */
switch (self->treeConfig) {
case TREE_212:
channelType[0] = ACT_FRONT;
channelIndices[0] = 0;
channelType[1] = ACT_FRONT;
channelIndices[1] = 1;
break;
default:;
}
}
}
/*******************************************************************************
Functionname: FDK_SpatialDecClose
*******************************************************************************
Description:
Arguments:
Return:
*******************************************************************************/
void FDK_SpatialDecClose(spatialDec *self) {
if (self) {
int k;
if (self->apDecor != NULL) {
for (k = 0; k < self->createParams.maxNumDecorChannels; k++) {
FDKdecorrelateClose(&(self->apDecor[k]));
}
FDK_FREE_MEMORY_1D(self->apDecor);
}
if (self->pDecorBufferCplx != NULL) {
FDK_FREE_MEMORY_2D(self->pDecorBufferCplx);
}
subbandTPDestroy(&self->hStpDec);
FDK_FREE_MEMORY_1D(self->reshapeBBEnvState);
FDK_FREE_MEMORY_1D(self->smoothState);
FDK_FREE_MEMORY_2D(self->pHybridAnaStatesLFdmx);
FDK_FREE_MEMORY_2D(self->pHybridAnaStatesHFdmx);
FDK_FREE_MEMORY_2D(self->pHybridAnaStatesLFres);
FDK_FREE_MEMORY_2D(self->pHybridAnaStatesHFres);
FDK_FREE_MEMORY_1D(self->hybridAnalysis);
FDK_FREE_MEMORY_1D(self->hybridSynthesis);
/* The time buffer is passed to the decoder from outside to avoid copying
* (zero copy). */
/* FDK_FREE_MEMORY_2D(self->timeOut__FDK); */
FDK_FREE_MEMORY_2D(self->hybOutputImagWet__FDK);
FDK_FREE_MEMORY_2D(self->hybOutputRealWet__FDK);
FDK_FREE_MEMORY_2D(self->hybOutputImagDry__FDK);
FDK_FREE_MEMORY_2D(self->hybOutputRealDry__FDK);
FDK_FREE_MEMORY_2D(self->wImag__FDK);
FDK_FREE_MEMORY_2D(self->wReal__FDK);
if (self->createParams.bProcResidual) {
int i;
for (i = 0; i < self->createParams.maxNumResChannels; i++) {
if (self->hybResidualImag__FDK != NULL)
FDK_FREE_MEMORY_1D(self->hybResidualImag__FDK[i]);
if (self->hybResidualReal__FDK != NULL)
FDK_FREE_MEMORY_1D(self->hybResidualReal__FDK[i]);
if (self->qmfResidualImag__FDK != NULL)
FDK_FREE_MEMORY_2D_ALIGNED(self->qmfResidualImag__FDK[i]);
if (self->qmfResidualReal__FDK != NULL)
FDK_FREE_MEMORY_2D_ALIGNED(self->qmfResidualReal__FDK[i]);
}
FDK_FREE_MEMORY_1D(self->hybResidualImag__FDK);
FDK_FREE_MEMORY_1D(self->hybResidualReal__FDK);
FDK_FREE_MEMORY_1D(self->qmfResidualImag__FDK);
FDK_FREE_MEMORY_1D(self->qmfResidualReal__FDK);
} /* self->createParams.bProcResidual */
FDK_FREE_MEMORY_2D(self->hybInputImag__FDK);
FDK_FREE_MEMORY_2D(self->hybInputReal__FDK);
FDK_FREE_MEMORY_2D_ALIGNED(self->qmfInputImag__FDK);
FDK_FREE_MEMORY_2D_ALIGNED(self->qmfInputReal__FDK);
FDK_FREE_MEMORY_3D(self->M2ImagPrev__FDK);
FDK_FREE_MEMORY_3D(self->M2RealPrev__FDK);
FDK_FREE_MEMORY_3D(self->M2Imag__FDK);
FDK_FREE_MEMORY_3D(self->M2Real__FDK);
FDK_FREE_MEMORY_1D(self->arbdmxAlphaPrev__FDK);
FDK_FREE_MEMORY_1D(self->arbdmxAlpha__FDK);
FDK_FREE_MEMORY_3D(self->arbdmxGain__FDK);
FDK_FREE_MEMORY_3D(self->ottIPD__FDK);
FDK_FREE_MEMORY_3D(self->ottICC__FDK);
FDK_FREE_MEMORY_3D(self->ottCLD__FDK);
/* Last parameters from prev frame */
FDK_FREE_MEMORY_2D(self->ottCLDidxPrev);
FDK_FREE_MEMORY_2D(self->ottICCidxPrev);
FDK_FREE_MEMORY_3D(self->ottICCdiffidx);
FDK_FREE_MEMORY_2D(self->ottIPDidxPrev);
FDK_FREE_MEMORY_2D(self->arbdmxGainIdxPrev);
FDK_FREE_MEMORY_2D(self->cmpOttCLDidxPrev);
FDK_FREE_MEMORY_2D(self->cmpOttICCidxPrev);
FDK_FREE_MEMORY_3D(self->outIdxData);
FDK_FREE_MEMORY_2D(self->cmpOttIPDidxPrev);
FDK_FREE_MEMORY_2D(self->cmpArbdmxGainIdxPrev);
FDK_FREE_MEMORY_2D(self->smgData);
FDK_FREE_MEMORY_1D(self->smgTime);
FDK_FREE_MEMORY_1D(self->numOttBands);
FDK_FREE_MEMORY_1D(self->param2hyb);
FDK_FREE_MEMORY_1D(self);
}
return;
}
/**
* \brief Apply Surround bypass buffer copies
* \param self spatialDec handle
* \param hybInputReal
* \param hybInputImag
* \param hybOutputReal
* \param hybOutputImag
* \param numInputChannels amount if input channels available in hybInputReal
* and hybInputImag, which may differ from self->numInputChannels.
*/
static void SpatialDecApplyBypass(spatialDec *self, FIXP_DBL **hybInputReal,
FIXP_DBL **hybInputImag,
FIXP_DBL **hybOutputReal,
FIXP_DBL **hybOutputImag,
const int numInputChannels) {
int complexHybBands;
complexHybBands = self->hybridBands;
{
int ch;
int rf = -1, lf = -1, cf = -1; /* Right Front, Left Front, Center Front */
/* Determine output channel indices according to tree config */
switch (self->treeConfig) {
case TREE_212: /* 212 */
lf = 0;
rf = 1;
break;
default:;
}
/* Note: numInputChannels might not match the tree config ! */
switch (numInputChannels) {
case 1:
if (cf > 0) {
FDKmemcpy(hybOutputReal[cf], hybInputReal[0],
self->hybridBands * sizeof(FIXP_DBL));
FDKmemcpy(hybOutputImag[cf], hybInputImag[0],
complexHybBands * sizeof(FIXP_DBL));
} else {
FDKmemcpy(hybOutputReal[lf], hybInputReal[0],
self->hybridBands * sizeof(FIXP_DBL));
FDKmemcpy(hybOutputReal[rf], hybInputReal[0],
self->hybridBands * sizeof(FIXP_DBL));
FDKmemcpy(hybOutputImag[lf], hybInputImag[0],
complexHybBands * sizeof(FIXP_DBL));
FDKmemcpy(hybOutputImag[rf], hybInputImag[0],
complexHybBands * sizeof(FIXP_DBL));
}
break;
case 2:
FDK_ASSERT(lf != -1);
FDK_ASSERT(rf != -1);
FDKmemcpy(hybOutputReal[lf], hybInputReal[0],
self->hybridBands * sizeof(FIXP_DBL));
FDKmemcpy(hybOutputReal[rf], hybInputReal[1],
self->hybridBands * sizeof(FIXP_DBL));
FDKmemcpy(hybOutputImag[lf], hybInputImag[0],
complexHybBands * sizeof(FIXP_DBL));
FDKmemcpy(hybOutputImag[rf], hybInputImag[1],
complexHybBands * sizeof(FIXP_DBL));
break;
}
for (ch = 0; ch < self->numOutputChannelsAT; ch++) {
if (ch == lf || ch == rf || ch == cf) {
continue; /* Skip bypassed channels */
}
FDKmemclear(hybOutputReal[ch], self->hybridBands * sizeof(FIXP_DBL));
FDKmemclear(hybOutputImag[ch], complexHybBands * sizeof(FIXP_DBL));
}
}
}
/*******************************************************************************
Functionname: SpatialDecApplyParameterSets
*******************************************************************************
Description:
Arguments:
Return:
*******************************************************************************/
static SACDEC_ERROR SpatialDecApplyParameterSets(
spatialDec *self, const SPATIAL_BS_FRAME *frame, SPATIALDEC_INPUT_MODE mode,
PCM_MPS *inData, /* Time domain input */
FIXP_DBL **qmfInDataReal, /* QMF domain data l/r */
FIXP_DBL **qmfInDataImag, /* QMF domain data l/r */
UINT nSamples, UINT controlFlags, int numInputChannels,
const FDK_channelMapDescr *const mapDescr) {
SACDEC_ERROR err = MPS_OK;
FIXP_SGL alpha;
int ts;
int ch;
int hyb;
int prevSlot = self->prevTimeSlot;
int ps = self->curPs;
int ts_io = 0; /* i/o dependent slot */
int bypassMode = (controlFlags & MPEGS_BYPASSMODE) ? 1 : 0;
/* Bypass can be triggered by the upmixType, too. */
bypassMode |= ((self->upmixType == UPMIXTYPE_BYPASS) ? 1 : 0);
/*
* Decode available slots
*/
for (ts = self->curTimeSlot;
ts <= fixMin(self->curTimeSlot + (int)nSamples / self->qmfBands - 1,
self->timeSlots - 1);
ts++, ts_io++) {
int currSlot = frame->paramSlot[ps];
/*
* Get new parameter set
*/
if (ts == prevSlot + 1) {
err = SpatialDecCalculateM1andM2(self, ps,
frame); /* input: ottCLD, ottICC, ... */
/* output: M1param(Real/Imag), M2(Real/Imag) */
if (err != MPS_OK) {
bypassMode = 1;
if (self->errInt == MPS_OK) {
/* store internal error befor it gets overwritten */
self->errInt = err;
}
err = MPS_OK;
}
if ((ps == 0) && (self->bOverwriteM1M2prev != 0)) {
/* copy matrix entries of M1/M2 of the first parameter set to the
previous matrices (of the last frame). This avoids the interpolation
of incompatible values. E.g. for residual bands the coefficients are
calculated differently compared to non-residual bands.
*/
SpatialDecBufferMatrices(self); /* input: M(1/2)param(Real/Imag) */
/* output: M(1/2)param(Real/Imag)Prev */
self->bOverwriteM1M2prev = 0;
}
SpatialDecSmoothM1andM2(
self, frame,
ps); /* input: M1param(Real/Imag)(Prev), M2(Real/Imag)(Prev) */
/* output: M1param(Real/Imag), M2(Real/Imag) */
}
alpha = FX_DBL2FX_SGL(fDivNorm(ts - prevSlot, currSlot - prevSlot));
switch (mode) {
case INPUTMODE_QMF_SBR:
if (self->pConfigCurrent->syntaxFlags & SACDEC_SYNTAX_LD)
self->bShareDelayWithSBR = 0; /* We got no hybrid delay */
else
self->bShareDelayWithSBR = 1;
SpatialDecFeedQMF(self, qmfInDataReal, qmfInDataImag, ts_io, bypassMode,
self->qmfInputReal__FDK, self->qmfInputImag__FDK,
self->numInputChannels);
break;
case INPUTMODE_TIME:
self->bShareDelayWithSBR = 0;
SpatialDecQMFAnalysis(self, inData, ts_io, bypassMode,
self->qmfInputReal__FDK, self->qmfInputImag__FDK,
self->numInputChannels);
break;
default:
break;
}
if ((self->pConfigCurrent->syntaxFlags & SACDEC_SYNTAX_USAC) &&
self->residualCoding) {
int offset;
ch = 1;
offset = self->pQmfDomain->globalConf.nBandsSynthesis *
self->pQmfDomain->globalConf.nQmfTimeSlots;
{
const PCM_MPS *inSamples =
&inData[ts * self->pQmfDomain->globalConf.nBandsAnalysis];
CalculateSpaceAnalysisQmf(
&self->pQmfDomain->QmfDomainIn[ch].fb, inSamples + (ch * offset),
self->qmfResidualReal__FDK[0][0], self->qmfResidualImag__FDK[0][0]);
if (!isTwoChMode(self->upmixType) && !bypassMode) {
int i;
FIXP_DBL *RESTRICT self_qmfResidualReal__FDK_0_0 =
&self->qmfResidualReal__FDK[0][0][0];
FIXP_DBL *RESTRICT self_qmfResidualImag__FDK_0_0 =
&self->qmfResidualImag__FDK[0][0][0];
if ((self->pQmfDomain->globalConf.nBandsAnalysis == 24) &&
!(self->stereoConfigIndex == 3)) {
for (i = 0; i < self->qmfBands; i++) {
self_qmfResidualReal__FDK_0_0[i] =
fMult(scaleValueSaturate(self_qmfResidualReal__FDK_0_0[i],
1 + self->sacInDataHeadroom - (1)),
self->clipProtectGain__FDK);
self_qmfResidualImag__FDK_0_0[i] =
fMult(scaleValueSaturate(self_qmfResidualImag__FDK_0_0[i],
1 + self->sacInDataHeadroom - (1)),
self->clipProtectGain__FDK);
}
} else {
for (i = 0; i < self->qmfBands; i++) {
self_qmfResidualReal__FDK_0_0[i] =
fMult(scaleValueSaturate(self_qmfResidualReal__FDK_0_0[i],
self->sacInDataHeadroom - (1)),
self->clipProtectGain__FDK);
self_qmfResidualImag__FDK_0_0[i] =
fMult(scaleValueSaturate(self_qmfResidualImag__FDK_0_0[i],
self->sacInDataHeadroom - (1)),
self->clipProtectGain__FDK);
}
}
}
}
}
SpatialDecHybridAnalysis(
self, /* input: qmfInput(Real/Imag), qmfResidual(Real/Imag) */
self->qmfInputReal__FDK, self->qmfInputImag__FDK,
self->hybInputReal__FDK, self->hybInputImag__FDK, ts, numInputChannels);
if (bypassMode) {
SpatialDecApplyBypass(
self, self->hybInputReal__FDK, /* input: hybInput(Real/Imag) */
self->hybInputImag__FDK,
self->hybOutputRealDry__FDK, /* output: hybOutput(Real/Imag)Dry */
self->hybOutputImagDry__FDK, numInputChannels);
} else /* !bypassMode */
{
FIXP_DBL *pxReal[MAX_NUM_XCHANNELS] = {NULL};
FIXP_DBL *pxImag[MAX_NUM_XCHANNELS] = {NULL};
SpatialDecCreateX(self,
self->hybInputReal__FDK, /* input: hybInput(Real/Imag),
hybResidual(Real/Imag) */
self->hybInputImag__FDK, pxReal, pxImag);
{
SpatialDecApplyM1_CreateW_Mode212(
self, frame, pxReal, pxImag,
self->wReal__FDK, /* output: w(Real/Imag) */
self->wImag__FDK);
}
if (err != MPS_OK) goto bail;
int applyM2Config = APPLY_M2_NONE;
applyM2Config = APPLY_M2;
if ((self->pConfigCurrent->syntaxFlags &
(SACDEC_SYNTAX_USAC | SACDEC_SYNTAX_RSVD50)) &&
(self->tempShapeConfig != 1) && (self->tempShapeConfig != 2)) {
if (self->phaseCoding == 3)
applyM2Config = APPLY_M2_MODE212_Res_PhaseCoding;
else
applyM2Config = APPLY_M2_MODE212;
}
switch (applyM2Config) {
case APPLY_M2_MODE212: {
err = SpatialDecApplyM2_Mode212(
self, ps, alpha, self->wReal__FDK, self->wImag__FDK,
self->hybOutputRealDry__FDK, self->hybOutputImagDry__FDK);
} break;
case APPLY_M2_MODE212_Res_PhaseCoding:
err = SpatialDecApplyM2_Mode212_ResidualsPlusPhaseCoding(
self, ps, alpha, self->wReal__FDK, self->wImag__FDK,
self->hybOutputRealDry__FDK, self->hybOutputImagDry__FDK);
break;
case APPLY_M2:
err = SpatialDecApplyM2(
self, ps, alpha, self->wReal__FDK, self->wImag__FDK,
self->hybOutputRealDry__FDK, self->hybOutputImagDry__FDK,
self->hybOutputRealWet__FDK, self->hybOutputImagWet__FDK);
break;
default:
err = MPS_APPLY_M2_ERROR;
goto bail;
}
if (err != MPS_OK) goto bail;
if ((self->tempShapeConfig == 2) && (!isTwoChMode(self->upmixType))) {
SpatialDecReshapeBBEnv(self, frame,
ts); /* input: reshapeBBEnvState,
hybOutput(Real/Imag)(Dry/Wet),
hybInput(Real/Imag) */
} /* output: hybOutput(Real/Imag)Dry */
/* Merge parts of the dry and wet QMF buffers. */
if ((self->tempShapeConfig == 1) && (!isTwoChMode(self->upmixType))) {
for (ch = 0; ch < self->numOutputChannels; ch++) {
for (hyb = 0; hyb < self->tp_hybBandBorder; hyb++) {
self->hybOutputRealDry__FDK[ch][hyb] =
fAddSaturate(self->hybOutputRealDry__FDK[ch][hyb],
self->hybOutputRealWet__FDK[ch][hyb]);
self->hybOutputImagDry__FDK[ch][hyb] =
fAddSaturate(self->hybOutputImagDry__FDK[ch][hyb],
self->hybOutputImagWet__FDK[ch][hyb]);
} /* loop hyb */
} /* loop ch */
err = subbandTPApply(
self, frame); /* input: hStpDec, hybOutput(Real/Imag)Dry/Wet */
/* output: hStpDec, hybOutput(Real/Imag)Dry */
if (err != MPS_OK) goto bail;
} /* (self->tempShapeConfig == 1) */
else {
/* The wet signal is added to the dry signal in applyM2 if GES and STP
* are disabled */
if ((self->tempShapeConfig == 1) || (self->tempShapeConfig == 2)) {
int nHybBands;
nHybBands = self->hybridBands;
for (ch = 0; ch < self->numOutputChannels; ch++) {
FIXP_DBL *RESTRICT pRealDry = self->hybOutputRealDry__FDK[ch];
FIXP_DBL *RESTRICT pImagDry = self->hybOutputImagDry__FDK[ch];
FIXP_DBL *RESTRICT pRealWet = self->hybOutputRealWet__FDK[ch];
FIXP_DBL *RESTRICT pImagWet = self->hybOutputImagWet__FDK[ch];
for (hyb = 0; hyb < nHybBands; hyb++) {
pRealDry[hyb] = fAddSaturate(pRealDry[hyb], pRealWet[hyb]);
pImagDry[hyb] = fAddSaturate(pImagDry[hyb], pImagWet[hyb]);
} /* loop hyb */
for (; hyb < self->hybridBands; hyb++) {
pRealDry[hyb] = fAddSaturate(pRealDry[hyb], pRealWet[hyb]);
} /* loop hyb */
} /* loop ch */
} /* ( self->tempShapeConfig == 1 ) || ( self->tempShapeConfig == 2 ) */
} /* !self->tempShapeConfig == 1 */
} /* !bypassMode */
if (self->phaseCoding == 1) {
/* only if bsPhaseCoding == 1 and bsResidualCoding == 0 */
SpatialDecApplyPhase(
self, alpha, (ts == currSlot) /* signal the last slot of the set */
);
}
/*
* Synthesis Filtering
*/
err = SpatialDecSynthesis(
self, ts_io,
self->hybOutputRealDry__FDK, /* input: hybOutput(Real/Imag)Dry */
self->hybOutputImagDry__FDK, self->timeOut__FDK, /* output: timeOut */
numInputChannels, mapDescr);
if (err != MPS_OK) goto bail;
/*
* Update parameter buffer
*/
if (ts == currSlot) {
SpatialDecBufferMatrices(self); /* input: M(1/2)param(Real/Imag) */
/* output: M(1/2)param(Real/Imag)Prev */
prevSlot = currSlot;
ps++;
} /* if (ts==currSlot) */
} /* ts loop */
/*
* Save parameter states
*/
self->prevTimeSlot = prevSlot;
self->curTimeSlot = ts;
self->curPs = ps;
bail:
return err;
}
SACDEC_ERROR SpatialDecApplyFrame(
spatialDec *self,
SPATIAL_BS_FRAME *frame, /* parsed frame data to be applied */
SPATIALDEC_INPUT_MODE inputMode, PCM_MPS *inData, /* Time domain input */
FIXP_DBL **qmfInDataReal, /* QMF domain data l/r */
FIXP_DBL **qmfInDataImag, /* QMF domain data l/r */
PCM_MPS *pcmOutBuf, /* MAX_OUTPUT_CHANNELS*MAX_TIME_SLOTS*NUM_QMF_BANDS] */
UINT nSamples, UINT *pControlFlags, int numInputChannels,
const FDK_channelMapDescr *const mapDescr) {
SACDEC_ERROR err = MPS_OK;
int fDecAndMapFrameData;
int controlFlags;
FDK_ASSERT(self != NULL);
FDK_ASSERT(pControlFlags != NULL);
FDK_ASSERT(pcmOutBuf != NULL);
FDK_ASSERT(self->sacInDataHeadroom >= (1));
self->errInt = err; /* Init internal error */
controlFlags = *pControlFlags;
if ((self->pConfigCurrent->syntaxFlags & SACDEC_SYNTAX_USAC) &&
(self->stereoConfigIndex > 1)) {
numInputChannels =
1; /* Do not count residual channel as input channel. It is handled
seperately. */
}
/* Check if input amount of channels is consistent */
if (numInputChannels != self->numInputChannels) {
controlFlags |= MPEGS_CONCEAL;
if (numInputChannels > self->createParams.maxNumInputChannels) {
return MPS_INVALID_PARAMETER;
}
}
self->timeOut__FDK = pcmOutBuf;
/* Determine local function control flags */
fDecAndMapFrameData = frame->newBsData;
if (((fDecAndMapFrameData ==
0) /* assures that conceal flag will not be set for blind mode */
&& (self->curTimeSlot + (int)nSamples / self->qmfBands >
self->timeSlots)) ||
(frame->numParameterSets ==
0)) { /* New input samples but missing side info */
fDecAndMapFrameData = 1;
controlFlags |= MPEGS_CONCEAL;
}
if ((fDecAndMapFrameData == 0) &&
(frame->paramSlot[fMax(0, frame->numParameterSets - 1)] !=
(self->timeSlots - 1) ||
self->curTimeSlot >
frame->paramSlot[self->curPs])) { /* Detected faulty parameter slot
data. */
fDecAndMapFrameData = 1;
controlFlags |= MPEGS_CONCEAL;
}
/* Update concealment state machine */
SpatialDecConcealment_UpdateState(
&self->concealInfo,
(controlFlags & MPEGS_CONCEAL)
? 0
: 1); /* convert from conceal flag to frame ok flag */
if (fDecAndMapFrameData) {
/* Reset spatial framing control vars */
frame->newBsData = 0;
self->prevTimeSlot = -1;
self->curTimeSlot = 0;
self->curPs = 0;
if (controlFlags & MPEGS_CONCEAL) {
/* Reset frame data to avoid misconfiguration. */
SpatialDecClearFrameData(self, frame, &self->createParams);
}
{
err = SpatialDecDecodeFrame(self, frame); /* input: ... */
/* output: decodeAndMapFrameDATA */
}
if (err != MPS_OK) {
/* Rescue strategy is to apply bypass mode in order
to keep at least the downmix channels continuous. */
controlFlags |= MPEGS_CONCEAL;
if (self->errInt == MPS_OK) {
/* store internal error befor it gets overwritten */
self->errInt = err;
}
}
}
err = SpatialDecApplyParameterSets(
self, frame, inputMode, inData, qmfInDataReal, qmfInDataImag, nSamples,
controlFlags | ((err == MPS_OK) ? 0 : MPEGS_BYPASSMODE), numInputChannels,
mapDescr);
if (err != MPS_OK) {
goto bail;
}
bail:
*pControlFlags = controlFlags;
return err;
}
| [
"lifenglin314@outlook.com"
] | lifenglin314@outlook.com |
61f4766894f594dc22aba8845debdbc9a48308e7 | 346a0f7c2f439686bfb8be58918bba33c412fd01 | /template_func.cpp | 7f7a65de42b39ee886fc93af1242bd552a4209d4 | [] | no_license | Anandoganiya/c-cpp | d01b712a59cc4fa299a8e958a7481c39348a0996 | a3f04255827758c2aff885a3cb4d974a4a636ac4 | refs/heads/master | 2023-01-14T08:16:28.282766 | 2020-11-23T08:52:53 | 2020-11-23T08:52:53 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 632 | cpp | //Template function implementing bubble sort
#include<iostream>
using namespace std;
template<class T>
void bubble(T v[],int n)
{
for(int i=0;i<n;i++)
for(int j=n-1;i<j;j--)
if(v[j]<v[j-1])
{
swap(v[j],v[j-1]);
}
}
template<class X>
void swap(X &x , X &y)
{
X temp = x;
x = y;
y = temp;
}
int main()
{
int x[5] = {5,4,3,2,1};
float y[5] = {1.8,7.8,1.9,2.7,5.7};
bubble(x,5);
for(int i=0;i<5;i++)
cout<<x[i]<<" ";
cout<<endl;
bubble(y,5);
for(int i=0;i<5;i++)
cout<<y[i]<<" ";
return 0;
}
| [
"31859828+Anandoganiya@users.noreply.github.com"
] | 31859828+Anandoganiya@users.noreply.github.com |
2631b4a05792ca3de97a328f11b0f15243c8d8c3 | fa38e49073de3676f9d636e66e74f21d2fc9a991 | /Upnp/ControlPoint/Services/Cpp/Core/CpLinnCoUkUi2.cpp | 6f0e003f353023f5e2e6304cc50f70008e72731c | [] | no_license | daviddw/oss-public | d80f362ce8ef9e52ece912f59a6fd7865ca50e7b | 0f13c078f8c2a2454572315e0e0d707ca0feb785 | refs/heads/master | 2022-01-16T21:32:49.366486 | 2012-10-30T09:49:26 | 2012-10-30T09:49:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 52,800 | cpp | #include <Core/CpLinnCoUkUi2.h>
#include <CpProxy.h>
#include <CpiService.h>
#include <Thread.h>
#include <AsyncPrivate.h>
#include <Core/CpDevice.h>
using namespace Zapp;
class SyncDisplayTestPatternLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncDisplayTestPatternLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncDisplayTestPatternLinnCoUkUi2::SyncDisplayTestPatternLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncDisplayTestPatternLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndDisplayTestPattern(aAsync);
}
class SyncDisplayFillLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncDisplayFillLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncDisplayFillLinnCoUkUi2::SyncDisplayFillLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncDisplayFillLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndDisplayFill(aAsync);
}
class SyncDisplayClearLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncDisplayClearLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncDisplayClearLinnCoUkUi2::SyncDisplayClearLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncDisplayClearLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndDisplayClear(aAsync);
}
class SyncSetTestModeEnabledLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSetTestModeEnabledLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSetTestModeEnabledLinnCoUkUi2::SyncSetTestModeEnabledLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSetTestModeEnabledLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSetTestModeEnabled(aAsync);
}
class SyncSimulateInfraredInputLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSimulateInfraredInputLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSimulateInfraredInputLinnCoUkUi2::SyncSimulateInfraredInputLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSimulateInfraredInputLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSimulateInfraredInput(aAsync);
}
class SyncSimulateButtonInputLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSimulateButtonInputLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSimulateButtonInputLinnCoUkUi2::SyncSimulateButtonInputLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSimulateButtonInputLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSimulateButtonInput(aAsync);
}
class SyncSimulateLightSensorLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSimulateLightSensorLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSimulateLightSensorLinnCoUkUi2::SyncSimulateLightSensorLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSimulateLightSensorLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSimulateLightSensor(aAsync);
}
class SyncGetLightSensorDataLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncGetLightSensorDataLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TUint& aaLightLevel);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
TUint& iaLightLevel;
};
SyncGetLightSensorDataLinnCoUkUi2::SyncGetLightSensorDataLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TUint& aaLightLevel)
: iService(aService)
, iaLightLevel(aaLightLevel)
{
}
void SyncGetLightSensorDataLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndGetLightSensorData(aAsync, iaLightLevel);
}
class SyncSetDisplayBrightnessLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSetDisplayBrightnessLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSetDisplayBrightnessLinnCoUkUi2::SyncSetDisplayBrightnessLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSetDisplayBrightnessLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSetDisplayBrightness(aAsync);
}
class SyncSetDisplayBrightnessAutoLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSetDisplayBrightnessAutoLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSetDisplayBrightnessAutoLinnCoUkUi2::SyncSetDisplayBrightnessAutoLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSetDisplayBrightnessAutoLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSetDisplayBrightnessAuto(aAsync);
}
class SyncSetInfraredCommandsLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSetInfraredCommandsLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSetInfraredCommandsLinnCoUkUi2::SyncSetInfraredCommandsLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSetInfraredCommandsLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSetInfraredCommands(aAsync);
}
class SyncInfraredCommandsLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncInfraredCommandsLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, Brh& aaCommands);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
Brh& iaCommands;
};
SyncInfraredCommandsLinnCoUkUi2::SyncInfraredCommandsLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, Brh& aaCommands)
: iService(aService)
, iaCommands(aaCommands)
{
}
void SyncInfraredCommandsLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndInfraredCommands(aAsync, iaCommands);
}
class SyncSetInfraredTerminalCommandsLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSetInfraredTerminalCommandsLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSetInfraredTerminalCommandsLinnCoUkUi2::SyncSetInfraredTerminalCommandsLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSetInfraredTerminalCommandsLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSetInfraredTerminalCommands(aAsync);
}
class SyncInfraredTerminalCommandsLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncInfraredTerminalCommandsLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, Brh& aaCommands);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
Brh& iaCommands;
};
SyncInfraredTerminalCommandsLinnCoUkUi2::SyncInfraredTerminalCommandsLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, Brh& aaCommands)
: iService(aService)
, iaCommands(aaCommands)
{
}
void SyncInfraredTerminalCommandsLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndInfraredTerminalCommands(aAsync, iaCommands);
}
class SyncDisplayBrightnessLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncDisplayBrightnessLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TUint& aaBrightness);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
TUint& iaBrightness;
};
SyncDisplayBrightnessLinnCoUkUi2::SyncDisplayBrightnessLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TUint& aaBrightness)
: iService(aService)
, iaBrightness(aaBrightness)
{
}
void SyncDisplayBrightnessLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndDisplayBrightness(aAsync, iaBrightness);
}
class SyncDisplayBrightnessAutoLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncDisplayBrightnessAutoLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TBool& aaBrightnessAuto);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
TBool& iaBrightnessAuto;
};
SyncDisplayBrightnessAutoLinnCoUkUi2::SyncDisplayBrightnessAutoLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TBool& aaBrightnessAuto)
: iService(aService)
, iaBrightnessAuto(aaBrightnessAuto)
{
}
void SyncDisplayBrightnessAutoLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndDisplayBrightnessAuto(aAsync, iaBrightnessAuto);
}
class SyncDisplayUpsideDownLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncDisplayUpsideDownLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TBool& aaUpsideDown);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
TBool& iaUpsideDown;
};
SyncDisplayUpsideDownLinnCoUkUi2::SyncDisplayUpsideDownLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TBool& aaUpsideDown)
: iService(aService)
, iaUpsideDown(aaUpsideDown)
{
}
void SyncDisplayUpsideDownLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndDisplayUpsideDown(aAsync, iaUpsideDown);
}
class SyncSetDisplayUpsideDownLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSetDisplayUpsideDownLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSetDisplayUpsideDownLinnCoUkUi2::SyncSetDisplayUpsideDownLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSetDisplayUpsideDownLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSetDisplayUpsideDown(aAsync);
}
class SyncSetDisplayScrollTextLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSetDisplayScrollTextLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSetDisplayScrollTextLinnCoUkUi2::SyncSetDisplayScrollTextLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSetDisplayScrollTextLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSetDisplayScrollText(aAsync);
}
class SyncDisplayScrollTextLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncDisplayScrollTextLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TBool& aaDisplayScrollTextEnabled);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
TBool& iaDisplayScrollTextEnabled;
};
SyncDisplayScrollTextLinnCoUkUi2::SyncDisplayScrollTextLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TBool& aaDisplayScrollTextEnabled)
: iService(aService)
, iaDisplayScrollTextEnabled(aaDisplayScrollTextEnabled)
{
}
void SyncDisplayScrollTextLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndDisplayScrollText(aAsync, iaDisplayScrollTextEnabled);
}
class SyncSetDisplaySleepLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSetDisplaySleepLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSetDisplaySleepLinnCoUkUi2::SyncSetDisplaySleepLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSetDisplaySleepLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSetDisplaySleep(aAsync);
}
class SyncDisplaySleepLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncDisplaySleepLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TBool& aaEnabled);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
TBool& iaEnabled;
};
SyncDisplaySleepLinnCoUkUi2::SyncDisplaySleepLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TBool& aaEnabled)
: iService(aService)
, iaEnabled(aaEnabled)
{
}
void SyncDisplaySleepLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndDisplaySleep(aAsync, iaEnabled);
}
class SyncSetDisplayLedOffLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncSetDisplayLedOffLinnCoUkUi2(CpProxyLinnCoUkUi2& aService);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
};
SyncSetDisplayLedOffLinnCoUkUi2::SyncSetDisplayLedOffLinnCoUkUi2(CpProxyLinnCoUkUi2& aService)
: iService(aService)
{
}
void SyncSetDisplayLedOffLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndSetDisplayLedOff(aAsync);
}
class SyncDisplayLedOffLinnCoUkUi2 : public SyncProxyAction
{
public:
SyncDisplayLedOffLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TBool& aaOff);
virtual void CompleteRequest(IAsync& aAsync);
private:
CpProxyLinnCoUkUi2& iService;
TBool& iaOff;
};
SyncDisplayLedOffLinnCoUkUi2::SyncDisplayLedOffLinnCoUkUi2(CpProxyLinnCoUkUi2& aService, TBool& aaOff)
: iService(aService)
, iaOff(aaOff)
{
}
void SyncDisplayLedOffLinnCoUkUi2::CompleteRequest(IAsync& aAsync)
{
iService.EndDisplayLedOff(aAsync, iaOff);
}
CpProxyLinnCoUkUi2::CpProxyLinnCoUkUi2(CpDevice& aDevice)
{
iService = new CpiService("linn-co-uk", "Ui", 2, aDevice.Device());
Zapp::Parameter* param;
TChar** allowedValues;
TUint index;
iActionDisplayTestPattern = new Action("DisplayTestPattern");
param = new Zapp::ParameterInt("aTestPattern", 0, 6);
iActionDisplayTestPattern->AddInputParameter(param);
iActionDisplayFill = new Action("DisplayFill");
iActionDisplayClear = new Action("DisplayClear");
iActionSetTestModeEnabled = new Action("SetTestModeEnabled");
param = new Zapp::ParameterBool("aEnabled");
iActionSetTestModeEnabled->AddInputParameter(param);
iActionSimulateInfraredInput = new Action("SimulateInfraredInput");
param = new Zapp::ParameterUint("aCode");
iActionSimulateInfraredInput->AddInputParameter(param);
iActionSimulateButtonInput = new Action("SimulateButtonInput");
param = new Zapp::ParameterUint("aCode");
iActionSimulateButtonInput->AddInputParameter(param);
iActionSimulateLightSensor = new Action("SimulateLightSensor");
param = new Zapp::ParameterUint("aLightLevel");
iActionSimulateLightSensor->AddInputParameter(param);
iActionGetLightSensorData = new Action("GetLightSensorData");
param = new Zapp::ParameterUint("aLightLevel");
iActionGetLightSensorData->AddOutputParameter(param);
iActionSetDisplayBrightness = new Action("SetDisplayBrightness");
param = new Zapp::ParameterUint("aBrightness");
iActionSetDisplayBrightness->AddInputParameter(param);
iActionSetDisplayBrightnessAuto = new Action("SetDisplayBrightnessAuto");
param = new Zapp::ParameterBool("aBrightnessAuto");
iActionSetDisplayBrightnessAuto->AddInputParameter(param);
iActionSetInfraredCommands = new Action("SetInfraredCommands");
index = 0;
allowedValues = new TChar*[4];
allowedValues[index++] = (TChar*)"None";
allowedValues[index++] = (TChar*)"All";
allowedValues[index++] = (TChar*)"Cd";
allowedValues[index++] = (TChar*)"Dvd";
param = new Zapp::ParameterString("aCommands", allowedValues, 4);
iActionSetInfraredCommands->AddInputParameter(param);
delete[] allowedValues;
iActionInfraredCommands = new Action("InfraredCommands");
index = 0;
allowedValues = new TChar*[4];
allowedValues[index++] = (TChar*)"None";
allowedValues[index++] = (TChar*)"All";
allowedValues[index++] = (TChar*)"Cd";
allowedValues[index++] = (TChar*)"Dvd";
param = new Zapp::ParameterString("aCommands", allowedValues, 4);
iActionInfraredCommands->AddOutputParameter(param);
delete[] allowedValues;
iActionSetInfraredTerminalCommands = new Action("SetInfraredTerminalCommands");
index = 0;
allowedValues = new TChar*[4];
allowedValues[index++] = (TChar*)"None";
allowedValues[index++] = (TChar*)"All";
allowedValues[index++] = (TChar*)"Cd";
allowedValues[index++] = (TChar*)"Dvd";
param = new Zapp::ParameterString("aCommands", allowedValues, 4);
iActionSetInfraredTerminalCommands->AddInputParameter(param);
delete[] allowedValues;
iActionInfraredTerminalCommands = new Action("InfraredTerminalCommands");
index = 0;
allowedValues = new TChar*[4];
allowedValues[index++] = (TChar*)"None";
allowedValues[index++] = (TChar*)"All";
allowedValues[index++] = (TChar*)"Cd";
allowedValues[index++] = (TChar*)"Dvd";
param = new Zapp::ParameterString("aCommands", allowedValues, 4);
iActionInfraredTerminalCommands->AddOutputParameter(param);
delete[] allowedValues;
iActionDisplayBrightness = new Action("DisplayBrightness");
param = new Zapp::ParameterUint("aBrightness");
iActionDisplayBrightness->AddOutputParameter(param);
iActionDisplayBrightnessAuto = new Action("DisplayBrightnessAuto");
param = new Zapp::ParameterBool("aBrightnessAuto");
iActionDisplayBrightnessAuto->AddOutputParameter(param);
iActionDisplayUpsideDown = new Action("DisplayUpsideDown");
param = new Zapp::ParameterBool("aUpsideDown");
iActionDisplayUpsideDown->AddOutputParameter(param);
iActionSetDisplayUpsideDown = new Action("SetDisplayUpsideDown");
param = new Zapp::ParameterBool("aUpsideDown");
iActionSetDisplayUpsideDown->AddInputParameter(param);
iActionSetDisplayScrollText = new Action("SetDisplayScrollText");
param = new Zapp::ParameterBool("aDisplayScrollText");
iActionSetDisplayScrollText->AddInputParameter(param);
iActionDisplayScrollText = new Action("DisplayScrollText");
param = new Zapp::ParameterBool("aDisplayScrollTextEnabled");
iActionDisplayScrollText->AddOutputParameter(param);
iActionSetDisplaySleep = new Action("SetDisplaySleep");
param = new Zapp::ParameterBool("aEnabled");
iActionSetDisplaySleep->AddInputParameter(param);
iActionDisplaySleep = new Action("DisplaySleep");
param = new Zapp::ParameterBool("aEnabled");
iActionDisplaySleep->AddOutputParameter(param);
iActionSetDisplayLedOff = new Action("SetDisplayLedOff");
param = new Zapp::ParameterBool("aOff");
iActionSetDisplayLedOff->AddInputParameter(param);
iActionDisplayLedOff = new Action("DisplayLedOff");
param = new Zapp::ParameterBool("aOff");
iActionDisplayLedOff->AddOutputParameter(param);
Functor functor;
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::DisplayBrightnessPropertyChanged);
iDisplayBrightness = new PropertyUint("DisplayBrightness", functor);
iService->AddProperty(iDisplayBrightness);
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::DisplayBrightnessAutoPropertyChanged);
iDisplayBrightnessAuto = new PropertyBool("DisplayBrightnessAuto", functor);
iService->AddProperty(iDisplayBrightnessAuto);
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::InfraredCommandsPropertyChanged);
iInfraredCommands = new PropertyString("InfraredCommands", functor);
iService->AddProperty(iInfraredCommands);
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::InfraredTerminalCommandsPropertyChanged);
iInfraredTerminalCommands = new PropertyString("InfraredTerminalCommands", functor);
iService->AddProperty(iInfraredTerminalCommands);
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::DisplayUpsideDownPropertyChanged);
iDisplayUpsideDown = new PropertyBool("DisplayUpsideDown", functor);
iService->AddProperty(iDisplayUpsideDown);
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::DisplayScrollTextPropertyChanged);
iDisplayScrollText = new PropertyBool("DisplayScrollText", functor);
iService->AddProperty(iDisplayScrollText);
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::DisplaySleepPropertyChanged);
iDisplaySleep = new PropertyBool("DisplaySleep", functor);
iService->AddProperty(iDisplaySleep);
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::DisplayLedOffPropertyChanged);
iDisplayLedOff = new PropertyBool("DisplayLedOff", functor);
iService->AddProperty(iDisplayLedOff);
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::TerminalInputCodePropertyChanged);
iTerminalInputCode = new PropertyUint("TerminalInputCode", functor);
iService->AddProperty(iTerminalInputCode);
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::TerminalInputNamePropertyChanged);
iTerminalInputName = new PropertyString("TerminalInputName", functor);
iService->AddProperty(iTerminalInputName);
functor = MakeFunctor(*this, &CpProxyLinnCoUkUi2::DisplayPixelsPropertyChanged);
iDisplayPixels = new PropertyBinary("DisplayPixels", functor);
iService->AddProperty(iDisplayPixels);
}
CpProxyLinnCoUkUi2::~CpProxyLinnCoUkUi2()
{
delete iService;
delete iActionDisplayTestPattern;
delete iActionDisplayFill;
delete iActionDisplayClear;
delete iActionSetTestModeEnabled;
delete iActionSimulateInfraredInput;
delete iActionSimulateButtonInput;
delete iActionSimulateLightSensor;
delete iActionGetLightSensorData;
delete iActionSetDisplayBrightness;
delete iActionSetDisplayBrightnessAuto;
delete iActionSetInfraredCommands;
delete iActionInfraredCommands;
delete iActionSetInfraredTerminalCommands;
delete iActionInfraredTerminalCommands;
delete iActionDisplayBrightness;
delete iActionDisplayBrightnessAuto;
delete iActionDisplayUpsideDown;
delete iActionSetDisplayUpsideDown;
delete iActionSetDisplayScrollText;
delete iActionDisplayScrollText;
delete iActionSetDisplaySleep;
delete iActionDisplaySleep;
delete iActionSetDisplayLedOff;
delete iActionDisplayLedOff;
}
void CpProxyLinnCoUkUi2::SyncDisplayTestPattern(TInt aaTestPattern)
{
SyncDisplayTestPatternLinnCoUkUi2 sync(*this);
BeginDisplayTestPattern(aaTestPattern, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginDisplayTestPattern(TInt aaTestPattern, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionDisplayTestPattern, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionDisplayTestPattern->InputParameters();
invocation->AddInput(new ArgumentInt(*inParams[inIndex++], aaTestPattern));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndDisplayTestPattern(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("DisplayTestPattern"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncDisplayFill()
{
SyncDisplayFillLinnCoUkUi2 sync(*this);
BeginDisplayFill(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginDisplayFill(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionDisplayFill, aFunctor);
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndDisplayFill(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("DisplayFill"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncDisplayClear()
{
SyncDisplayClearLinnCoUkUi2 sync(*this);
BeginDisplayClear(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginDisplayClear(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionDisplayClear, aFunctor);
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndDisplayClear(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("DisplayClear"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncSetTestModeEnabled(TBool aaEnabled)
{
SyncSetTestModeEnabledLinnCoUkUi2 sync(*this);
BeginSetTestModeEnabled(aaEnabled, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSetTestModeEnabled(TBool aaEnabled, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSetTestModeEnabled, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSetTestModeEnabled->InputParameters();
invocation->AddInput(new ArgumentBool(*inParams[inIndex++], aaEnabled));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSetTestModeEnabled(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SetTestModeEnabled"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncSimulateInfraredInput(TUint aaCode)
{
SyncSimulateInfraredInputLinnCoUkUi2 sync(*this);
BeginSimulateInfraredInput(aaCode, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSimulateInfraredInput(TUint aaCode, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSimulateInfraredInput, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSimulateInfraredInput->InputParameters();
invocation->AddInput(new ArgumentUint(*inParams[inIndex++], aaCode));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSimulateInfraredInput(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SimulateInfraredInput"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncSimulateButtonInput(TUint aaCode)
{
SyncSimulateButtonInputLinnCoUkUi2 sync(*this);
BeginSimulateButtonInput(aaCode, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSimulateButtonInput(TUint aaCode, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSimulateButtonInput, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSimulateButtonInput->InputParameters();
invocation->AddInput(new ArgumentUint(*inParams[inIndex++], aaCode));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSimulateButtonInput(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SimulateButtonInput"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncSimulateLightSensor(TUint aaLightLevel)
{
SyncSimulateLightSensorLinnCoUkUi2 sync(*this);
BeginSimulateLightSensor(aaLightLevel, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSimulateLightSensor(TUint aaLightLevel, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSimulateLightSensor, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSimulateLightSensor->InputParameters();
invocation->AddInput(new ArgumentUint(*inParams[inIndex++], aaLightLevel));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSimulateLightSensor(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SimulateLightSensor"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncGetLightSensorData(TUint& aaLightLevel)
{
SyncGetLightSensorDataLinnCoUkUi2 sync(*this, aaLightLevel);
BeginGetLightSensorData(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginGetLightSensorData(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionGetLightSensorData, aFunctor);
TUint outIndex = 0;
const Action::VectorParameters& outParams = iActionGetLightSensorData->OutputParameters();
invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndGetLightSensorData(IAsync& aAsync, TUint& aaLightLevel)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("GetLightSensorData"));
if (invocation.Error()) {
THROW(ProxyError);
}
TUint index = 0;
aaLightLevel = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
}
void CpProxyLinnCoUkUi2::SyncSetDisplayBrightness(TUint aaBrightness)
{
SyncSetDisplayBrightnessLinnCoUkUi2 sync(*this);
BeginSetDisplayBrightness(aaBrightness, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSetDisplayBrightness(TUint aaBrightness, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSetDisplayBrightness, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSetDisplayBrightness->InputParameters();
invocation->AddInput(new ArgumentUint(*inParams[inIndex++], aaBrightness));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSetDisplayBrightness(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SetDisplayBrightness"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncSetDisplayBrightnessAuto(TBool aaBrightnessAuto)
{
SyncSetDisplayBrightnessAutoLinnCoUkUi2 sync(*this);
BeginSetDisplayBrightnessAuto(aaBrightnessAuto, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSetDisplayBrightnessAuto(TBool aaBrightnessAuto, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSetDisplayBrightnessAuto, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSetDisplayBrightnessAuto->InputParameters();
invocation->AddInput(new ArgumentBool(*inParams[inIndex++], aaBrightnessAuto));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSetDisplayBrightnessAuto(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SetDisplayBrightnessAuto"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncSetInfraredCommands(const Brx& aaCommands)
{
SyncSetInfraredCommandsLinnCoUkUi2 sync(*this);
BeginSetInfraredCommands(aaCommands, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSetInfraredCommands(const Brx& aaCommands, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSetInfraredCommands, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSetInfraredCommands->InputParameters();
invocation->AddInput(new ArgumentString(*inParams[inIndex++], aaCommands));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSetInfraredCommands(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SetInfraredCommands"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncInfraredCommands(Brh& aaCommands)
{
SyncInfraredCommandsLinnCoUkUi2 sync(*this, aaCommands);
BeginInfraredCommands(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginInfraredCommands(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionInfraredCommands, aFunctor);
TUint outIndex = 0;
const Action::VectorParameters& outParams = iActionInfraredCommands->OutputParameters();
invocation->AddOutput(new ArgumentString(*outParams[outIndex++]));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndInfraredCommands(IAsync& aAsync, Brh& aaCommands)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("InfraredCommands"));
if (invocation.Error()) {
THROW(ProxyError);
}
TUint index = 0;
((ArgumentString*)invocation.OutputArguments()[index++])->TransferTo(aaCommands);
}
void CpProxyLinnCoUkUi2::SyncSetInfraredTerminalCommands(const Brx& aaCommands)
{
SyncSetInfraredTerminalCommandsLinnCoUkUi2 sync(*this);
BeginSetInfraredTerminalCommands(aaCommands, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSetInfraredTerminalCommands(const Brx& aaCommands, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSetInfraredTerminalCommands, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSetInfraredTerminalCommands->InputParameters();
invocation->AddInput(new ArgumentString(*inParams[inIndex++], aaCommands));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSetInfraredTerminalCommands(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SetInfraredTerminalCommands"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncInfraredTerminalCommands(Brh& aaCommands)
{
SyncInfraredTerminalCommandsLinnCoUkUi2 sync(*this, aaCommands);
BeginInfraredTerminalCommands(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginInfraredTerminalCommands(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionInfraredTerminalCommands, aFunctor);
TUint outIndex = 0;
const Action::VectorParameters& outParams = iActionInfraredTerminalCommands->OutputParameters();
invocation->AddOutput(new ArgumentString(*outParams[outIndex++]));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndInfraredTerminalCommands(IAsync& aAsync, Brh& aaCommands)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("InfraredTerminalCommands"));
if (invocation.Error()) {
THROW(ProxyError);
}
TUint index = 0;
((ArgumentString*)invocation.OutputArguments()[index++])->TransferTo(aaCommands);
}
void CpProxyLinnCoUkUi2::SyncDisplayBrightness(TUint& aaBrightness)
{
SyncDisplayBrightnessLinnCoUkUi2 sync(*this, aaBrightness);
BeginDisplayBrightness(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginDisplayBrightness(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionDisplayBrightness, aFunctor);
TUint outIndex = 0;
const Action::VectorParameters& outParams = iActionDisplayBrightness->OutputParameters();
invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndDisplayBrightness(IAsync& aAsync, TUint& aaBrightness)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("DisplayBrightness"));
if (invocation.Error()) {
THROW(ProxyError);
}
TUint index = 0;
aaBrightness = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
}
void CpProxyLinnCoUkUi2::SyncDisplayBrightnessAuto(TBool& aaBrightnessAuto)
{
SyncDisplayBrightnessAutoLinnCoUkUi2 sync(*this, aaBrightnessAuto);
BeginDisplayBrightnessAuto(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginDisplayBrightnessAuto(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionDisplayBrightnessAuto, aFunctor);
TUint outIndex = 0;
const Action::VectorParameters& outParams = iActionDisplayBrightnessAuto->OutputParameters();
invocation->AddOutput(new ArgumentBool(*outParams[outIndex++]));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndDisplayBrightnessAuto(IAsync& aAsync, TBool& aaBrightnessAuto)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("DisplayBrightnessAuto"));
if (invocation.Error()) {
THROW(ProxyError);
}
TUint index = 0;
aaBrightnessAuto = ((ArgumentBool*)invocation.OutputArguments()[index++])->Value();
}
void CpProxyLinnCoUkUi2::SyncDisplayUpsideDown(TBool& aaUpsideDown)
{
SyncDisplayUpsideDownLinnCoUkUi2 sync(*this, aaUpsideDown);
BeginDisplayUpsideDown(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginDisplayUpsideDown(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionDisplayUpsideDown, aFunctor);
TUint outIndex = 0;
const Action::VectorParameters& outParams = iActionDisplayUpsideDown->OutputParameters();
invocation->AddOutput(new ArgumentBool(*outParams[outIndex++]));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndDisplayUpsideDown(IAsync& aAsync, TBool& aaUpsideDown)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("DisplayUpsideDown"));
if (invocation.Error()) {
THROW(ProxyError);
}
TUint index = 0;
aaUpsideDown = ((ArgumentBool*)invocation.OutputArguments()[index++])->Value();
}
void CpProxyLinnCoUkUi2::SyncSetDisplayUpsideDown(TBool aaUpsideDown)
{
SyncSetDisplayUpsideDownLinnCoUkUi2 sync(*this);
BeginSetDisplayUpsideDown(aaUpsideDown, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSetDisplayUpsideDown(TBool aaUpsideDown, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSetDisplayUpsideDown, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSetDisplayUpsideDown->InputParameters();
invocation->AddInput(new ArgumentBool(*inParams[inIndex++], aaUpsideDown));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSetDisplayUpsideDown(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SetDisplayUpsideDown"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncSetDisplayScrollText(TBool aaDisplayScrollText)
{
SyncSetDisplayScrollTextLinnCoUkUi2 sync(*this);
BeginSetDisplayScrollText(aaDisplayScrollText, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSetDisplayScrollText(TBool aaDisplayScrollText, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSetDisplayScrollText, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSetDisplayScrollText->InputParameters();
invocation->AddInput(new ArgumentBool(*inParams[inIndex++], aaDisplayScrollText));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSetDisplayScrollText(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SetDisplayScrollText"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncDisplayScrollText(TBool& aaDisplayScrollTextEnabled)
{
SyncDisplayScrollTextLinnCoUkUi2 sync(*this, aaDisplayScrollTextEnabled);
BeginDisplayScrollText(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginDisplayScrollText(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionDisplayScrollText, aFunctor);
TUint outIndex = 0;
const Action::VectorParameters& outParams = iActionDisplayScrollText->OutputParameters();
invocation->AddOutput(new ArgumentBool(*outParams[outIndex++]));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndDisplayScrollText(IAsync& aAsync, TBool& aaDisplayScrollTextEnabled)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("DisplayScrollText"));
if (invocation.Error()) {
THROW(ProxyError);
}
TUint index = 0;
aaDisplayScrollTextEnabled = ((ArgumentBool*)invocation.OutputArguments()[index++])->Value();
}
void CpProxyLinnCoUkUi2::SyncSetDisplaySleep(TBool aaEnabled)
{
SyncSetDisplaySleepLinnCoUkUi2 sync(*this);
BeginSetDisplaySleep(aaEnabled, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSetDisplaySleep(TBool aaEnabled, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSetDisplaySleep, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSetDisplaySleep->InputParameters();
invocation->AddInput(new ArgumentBool(*inParams[inIndex++], aaEnabled));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSetDisplaySleep(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SetDisplaySleep"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncDisplaySleep(TBool& aaEnabled)
{
SyncDisplaySleepLinnCoUkUi2 sync(*this, aaEnabled);
BeginDisplaySleep(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginDisplaySleep(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionDisplaySleep, aFunctor);
TUint outIndex = 0;
const Action::VectorParameters& outParams = iActionDisplaySleep->OutputParameters();
invocation->AddOutput(new ArgumentBool(*outParams[outIndex++]));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndDisplaySleep(IAsync& aAsync, TBool& aaEnabled)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("DisplaySleep"));
if (invocation.Error()) {
THROW(ProxyError);
}
TUint index = 0;
aaEnabled = ((ArgumentBool*)invocation.OutputArguments()[index++])->Value();
}
void CpProxyLinnCoUkUi2::SyncSetDisplayLedOff(TBool aaOff)
{
SyncSetDisplayLedOffLinnCoUkUi2 sync(*this);
BeginSetDisplayLedOff(aaOff, sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginSetDisplayLedOff(TBool aaOff, FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionSetDisplayLedOff, aFunctor);
TUint inIndex = 0;
const Action::VectorParameters& inParams = iActionSetDisplayLedOff->InputParameters();
invocation->AddInput(new ArgumentBool(*inParams[inIndex++], aaOff));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndSetDisplayLedOff(IAsync& aAsync)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("SetDisplayLedOff"));
if (invocation.Error()) {
THROW(ProxyError);
}
}
void CpProxyLinnCoUkUi2::SyncDisplayLedOff(TBool& aaOff)
{
SyncDisplayLedOffLinnCoUkUi2 sync(*this, aaOff);
BeginDisplayLedOff(sync.Functor());
sync.Wait();
}
void CpProxyLinnCoUkUi2::BeginDisplayLedOff(FunctorAsync& aFunctor)
{
Invocation* invocation = iService->Invocation(*iActionDisplayLedOff, aFunctor);
TUint outIndex = 0;
const Action::VectorParameters& outParams = iActionDisplayLedOff->OutputParameters();
invocation->AddOutput(new ArgumentBool(*outParams[outIndex++]));
invocation->Invoke();
}
void CpProxyLinnCoUkUi2::EndDisplayLedOff(IAsync& aAsync, TBool& aaOff)
{
ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
Invocation& invocation = (Invocation&)aAsync;
ASSERT(invocation.Action().Name() == Brn("DisplayLedOff"));
if (invocation.Error()) {
THROW(ProxyError);
}
TUint index = 0;
aaOff = ((ArgumentBool*)invocation.OutputArguments()[index++])->Value();
}
void CpProxyLinnCoUkUi2::SetPropertyDisplayBrightnessChanged(Functor& aFunctor)
{
iLock->Wait();
iDisplayBrightnessChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::SetPropertyDisplayBrightnessAutoChanged(Functor& aFunctor)
{
iLock->Wait();
iDisplayBrightnessAutoChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::SetPropertyInfraredCommandsChanged(Functor& aFunctor)
{
iLock->Wait();
iInfraredCommandsChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::SetPropertyInfraredTerminalCommandsChanged(Functor& aFunctor)
{
iLock->Wait();
iInfraredTerminalCommandsChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::SetPropertyDisplayUpsideDownChanged(Functor& aFunctor)
{
iLock->Wait();
iDisplayUpsideDownChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::SetPropertyDisplayScrollTextChanged(Functor& aFunctor)
{
iLock->Wait();
iDisplayScrollTextChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::SetPropertyDisplaySleepChanged(Functor& aFunctor)
{
iLock->Wait();
iDisplaySleepChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::SetPropertyDisplayLedOffChanged(Functor& aFunctor)
{
iLock->Wait();
iDisplayLedOffChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::SetPropertyTerminalInputCodeChanged(Functor& aFunctor)
{
iLock->Wait();
iTerminalInputCodeChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::SetPropertyTerminalInputNameChanged(Functor& aFunctor)
{
iLock->Wait();
iTerminalInputNameChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::SetPropertyDisplayPixelsChanged(Functor& aFunctor)
{
iLock->Wait();
iDisplayPixelsChanged = aFunctor;
iLock->Signal();
}
void CpProxyLinnCoUkUi2::PropertyDisplayBrightness(TUint& aDisplayBrightness) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aDisplayBrightness = iDisplayBrightness->Value();
}
void CpProxyLinnCoUkUi2::PropertyDisplayBrightnessAuto(TBool& aDisplayBrightnessAuto) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aDisplayBrightnessAuto = iDisplayBrightnessAuto->Value();
}
void CpProxyLinnCoUkUi2::PropertyInfraredCommands(Brhz& aInfraredCommands) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aInfraredCommands.Set(iInfraredCommands->Value());
}
void CpProxyLinnCoUkUi2::PropertyInfraredTerminalCommands(Brhz& aInfraredTerminalCommands) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aInfraredTerminalCommands.Set(iInfraredTerminalCommands->Value());
}
void CpProxyLinnCoUkUi2::PropertyDisplayUpsideDown(TBool& aDisplayUpsideDown) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aDisplayUpsideDown = iDisplayUpsideDown->Value();
}
void CpProxyLinnCoUkUi2::PropertyDisplayScrollText(TBool& aDisplayScrollText) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aDisplayScrollText = iDisplayScrollText->Value();
}
void CpProxyLinnCoUkUi2::PropertyDisplaySleep(TBool& aDisplaySleep) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aDisplaySleep = iDisplaySleep->Value();
}
void CpProxyLinnCoUkUi2::PropertyDisplayLedOff(TBool& aDisplayLedOff) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aDisplayLedOff = iDisplayLedOff->Value();
}
void CpProxyLinnCoUkUi2::PropertyTerminalInputCode(TUint& aTerminalInputCode) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aTerminalInputCode = iTerminalInputCode->Value();
}
void CpProxyLinnCoUkUi2::PropertyTerminalInputName(Brhz& aTerminalInputName) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aTerminalInputName.Set(iTerminalInputName->Value());
}
void CpProxyLinnCoUkUi2::PropertyDisplayPixels(Brh& aDisplayPixels) const
{
ASSERT(iCpSubscriptionStatus == CpProxy::eSubscribed);
aDisplayPixels.Set(iDisplayPixels->Value());
}
void CpProxyLinnCoUkUi2::DisplayBrightnessPropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iDisplayBrightnessChanged != NULL) {
iDisplayBrightnessChanged();
}
}
void CpProxyLinnCoUkUi2::DisplayBrightnessAutoPropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iDisplayBrightnessAutoChanged != NULL) {
iDisplayBrightnessAutoChanged();
}
}
void CpProxyLinnCoUkUi2::InfraredCommandsPropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iInfraredCommandsChanged != NULL) {
iInfraredCommandsChanged();
}
}
void CpProxyLinnCoUkUi2::InfraredTerminalCommandsPropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iInfraredTerminalCommandsChanged != NULL) {
iInfraredTerminalCommandsChanged();
}
}
void CpProxyLinnCoUkUi2::DisplayUpsideDownPropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iDisplayUpsideDownChanged != NULL) {
iDisplayUpsideDownChanged();
}
}
void CpProxyLinnCoUkUi2::DisplayScrollTextPropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iDisplayScrollTextChanged != NULL) {
iDisplayScrollTextChanged();
}
}
void CpProxyLinnCoUkUi2::DisplaySleepPropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iDisplaySleepChanged != NULL) {
iDisplaySleepChanged();
}
}
void CpProxyLinnCoUkUi2::DisplayLedOffPropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iDisplayLedOffChanged != NULL) {
iDisplayLedOffChanged();
}
}
void CpProxyLinnCoUkUi2::TerminalInputCodePropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iTerminalInputCodeChanged != NULL) {
iTerminalInputCodeChanged();
}
}
void CpProxyLinnCoUkUi2::TerminalInputNamePropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iTerminalInputNameChanged != NULL) {
iTerminalInputNameChanged();
}
}
void CpProxyLinnCoUkUi2::DisplayPixelsPropertyChanged()
{
if (!ReportEvent()) {
return;
}
AutoMutex a(*iLock);
if (iCpSubscriptionStatus == CpProxy::eSubscribed && iDisplayPixelsChanged != NULL) {
iDisplayPixelsChanged();
}
}
| [
"davidd@f930c5cb-86ff-4d92-8e31-4eab6bb26c19"
] | davidd@f930c5cb-86ff-4d92-8e31-4eab6bb26c19 |
e736c822cacdbb9aab4ec93b62e53bac56e31ae3 | 4e5cd0b82c188e2eb5e8562d01798314a9405eff | /src/test/TestTSLQueue.cpp | f579712237fcf492ded1bc3dcea81e9530641a1d | [
"MIT"
] | permissive | Stephen-Seo/UDPConnection | d31d0ba74ab7fe3675002fa1fabced723985db2c | 611287b377bcf4c4fa717134f6e938af5e161e83 | refs/heads/master | 2023-08-16T19:55:12.819429 | 2023-07-22T08:28:18 | 2023-07-22T08:28:33 | 233,561,342 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,458 | cpp | #include <gtest/gtest.h>
#include <future>
#include <functional>
#include "TSLQueue.hpp"
TEST(TSLQueue, PushTopPopSize) {
TSLQueue<int> q;
EXPECT_FALSE(q.top());
for(int i = 0; i < 10; ++i) {
EXPECT_EQ(i, q.size());
q.push(i);
}
for(int i = 0; i < 10; ++i) {
auto v = q.top();
ASSERT_TRUE(v);
EXPECT_EQ(*v, i);
EXPECT_EQ(10 - i, q.size());
EXPECT_TRUE(q.pop());
}
EXPECT_EQ(q.size(), 0);
EXPECT_FALSE(q.pop());
}
TEST(TSLQueue, PushNB_TopNB_TopAndPop_Size) {
TSLQueue<int> q;
for(int i = 0; i < 10; ++i) {
EXPECT_EQ(q.size(), i);
EXPECT_TRUE(q.push_nb(i));
}
for(int i = 0; i < 10; ++i) {
auto v = q.top_nb();
ASSERT_TRUE(v);
EXPECT_EQ(*v, i);
EXPECT_EQ(q.size(), 10 - i);
v = q.top_and_pop();
ASSERT_TRUE(v);
EXPECT_EQ(*v, i);
}
{
auto v = q.top_nb();
ASSERT_FALSE(v);
}
{
auto v = q.top_and_pop();
ASSERT_FALSE(v);
}
EXPECT_EQ(q.size(), 0);
}
TEST(TSLQueue, Push_TopAndPopAndEmpty_Size) {
TSLQueue<int> q;
for(int i = 0; i < 10; ++i) {
EXPECT_EQ(q.size(), i);
q.push(i);
}
bool isEmpty;
for(int i = 0; i < 10; ++i) {
EXPECT_EQ(q.size(), 10 - i);
auto v = q.top_and_pop_and_empty(&isEmpty);
ASSERT_TRUE(v);
EXPECT_EQ(*v, i);
EXPECT_EQ(i == 9, isEmpty);
}
EXPECT_EQ(q.size(), 0);
}
TEST(TSLQueue, PushClearEmptySize) {
TSLQueue<int> q;
for(int i = 0; i < 10; ++i) {
EXPECT_EQ(q.size(), i);
q.push(i);
}
EXPECT_EQ(q.size(), 10);
EXPECT_FALSE(q.empty());
q.clear();
EXPECT_TRUE(q.empty());
EXPECT_EQ(q.size(), 0);
}
TEST(TSLQueue, Concurrent) {
TSLQueue<int> q;
const auto add_fn = [] (TSLQueue<int> *q, int i) -> void {
q->push(i);
};
std::future<void> futures[100];
for(int i = 0; i < 100; ++i) {
futures[i] = std::async(std::launch::async, add_fn, &q, i);
}
for(int i = 0; i < 100; ++i) {
futures[i].wait();
}
EXPECT_FALSE(q.empty());
for(int i = 0; i < 100; ++i) {
EXPECT_EQ(q.size(), 100 - i);
auto v = q.top_and_pop();
ASSERT_TRUE(v);
EXPECT_GE(*v, 0);
EXPECT_LE(*v, 100);
EXPECT_EQ(i == 99, q.empty());
}
EXPECT_EQ(q.size(), 0);
}
TEST(TSLQueue, Iterator) {
TSLQueue<int> q;
for(int i = 0; i < 10; ++i) {
q.push(i);
}
EXPECT_EQ(q.size(), 10);
{
// iteration
auto iter = q.begin();
int i = 0;
auto op = iter.current();
while(op) {
EXPECT_EQ(*op, i++);
if(i < 10) {
EXPECT_TRUE(iter.next());
} else {
EXPECT_FALSE(iter.next());
}
op = iter.current();
}
// test that lock is held by iterator
EXPECT_FALSE(q.push_nb(10));
op = q.top_nb();
EXPECT_FALSE(op);
// backwards iteration
EXPECT_TRUE(iter.prev());
op = iter.current();
while(op) {
EXPECT_EQ(*op, --i);
if(i > 0) {
EXPECT_TRUE(iter.prev());
} else {
EXPECT_FALSE(iter.prev());
}
op = iter.current();
}
}
{
// iter remove
auto iter = q.begin();
EXPECT_TRUE(iter.next());
EXPECT_TRUE(iter.next());
EXPECT_TRUE(iter.next());
EXPECT_TRUE(iter.remove());
auto op = iter.current();
EXPECT_TRUE(op);
EXPECT_EQ(*op, 4);
EXPECT_TRUE(iter.prev());
op = iter.current();
EXPECT_TRUE(op);
EXPECT_EQ(*op, 2);
}
EXPECT_EQ(q.size(), 9);
// check that "3" was removed from queue
int i = 0;
std::unique_ptr<int> op;
while(!q.empty()) {
op = q.top();
EXPECT_TRUE(op);
EXPECT_EQ(i++, *op);
if(i == 3) {
++i;
}
EXPECT_TRUE(q.pop());
}
// remove from start
q.push(0);
q.push(1);
q.push(2);
q.push(3);
EXPECT_EQ(q.size(), 4);
{
auto iter = q.begin();
EXPECT_TRUE(iter.remove());
}
EXPECT_EQ(q.size(), 3);
i = 1;
while(!q.empty()) {
op = q.top();
EXPECT_TRUE(op);
EXPECT_EQ(i++, *op);
EXPECT_TRUE(q.pop());
}
// remove from end
q.push(0);
q.push(1);
q.push(2);
q.push(3);
EXPECT_EQ(q.size(), 4);
{
auto iter = q.begin();
while(true) {
EXPECT_TRUE(iter.next());
op = iter.current();
EXPECT_TRUE(op);
if(*op == 3) {
EXPECT_FALSE(iter.remove());
break;
}
}
}
EXPECT_EQ(q.size(), 3);
i = 0;
while(!q.empty()) {
op = q.top();
EXPECT_TRUE(op);
EXPECT_EQ(i++, *op);
EXPECT_TRUE(q.pop());
if(i == 3) {
EXPECT_TRUE(q.empty());
}
}
}
TEST(TSLQueue, TempToNew) {
TSLQueue<int> q;
q.push(1234);
q.push(5678);
auto getValue = [] (TSLQueue<int> *q) -> int {
auto uptr = q->top_and_pop();
return *uptr;
};
int value;
value = getValue(&q);
EXPECT_EQ(1234, value);
value = getValue(&q);
EXPECT_EQ(5678, value);
}
| [
"seo.disparate@gmail.com"
] | seo.disparate@gmail.com |
2e91f4eb238a1bf205397459ee6c7870cfd1274c | 4f4de6e42893dd12a4e31fb23f8a265e56df480d | /source/backend/cpu/compute/ConvInt83x3.cpp | 048fdb91e94d28c4d5490bf7edc449e511792b5f | [
"Apache-2.0"
] | permissive | mapnn/MNN | 01fd680b14a3e04624576dffe393f1495f4202e1 | d203b50fef7107ef3ae5716e1aa2481aea6e8159 | refs/heads/master | 2023-02-12T02:31:34.512694 | 2020-12-31T07:17:51 | 2020-12-31T07:17:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 39,561 | cpp | #include "ConvInt83x3.hpp"
#include "backend/cpu/CPUBackend.hpp"
#include "core/Macro.h"
#include "core/Concurrency.h"
#include "ConvOpt.h"
#include "backend/cpu/compute/ConvOpt.h"
#include "Int8FunctionsOpt.h"
#include "CommonOptFunction.h"
#include "WinogradHelper.hpp"
#include "MNN/AutoTime.hpp"
#include <map>
#include <string>
#include <memory>
#include <vector>
#ifdef MNN_USE_NEON
#include <arm_neon.h>
#endif
static const int BLOCK_UNIT = MNN::WinogradHelper::L2K3::blockUnit();
static const int SRC_UNIT = MNN::WinogradHelper::L2K3::srcUnit();
static const int DST_UNIT = MNN::WinogradHelper::L2K3::dstUnit();
static const int BLOCK_UNIT2 = BLOCK_UNIT * BLOCK_UNIT;
static const int GEMM_TILE_UNIT = DST_XUNIT;
using namespace MNN::WinogradHelper::L2K3;
namespace MNN {
/*
w0: original int8 weight (3x3), 1x
w1_{int8, int16}: winograd transformed (2-dim) weight (4x4, two dim), (4x4)/(3x3) = 1.77x for int8, 3.54x for int16
w2_{int8, int16}: winograd transformed (1-dim, horizontal and vertical) weight (2x3x4, one dim), (2x3x4)/(3x3) = 2.66x, 5.32x for int16
w3: original int16 weight (3x3), (int16 / int8) = 2x
1. Memory usage Analysis
[[static memory], [dynamic memory]]
|-- int8
|---- combine1D2D
| |--- Online: [[w0], [w1_int8, w2_int8]] 1x
| |--- ExtraOnline: [[w0, w1_int8], [w2_int8]] 2.77x
| |--- Offline: [[w0, w1_int8, w2_int8], []] 5.44x
|
|------ only2D
|--- Online: [[w0], [w1_int8]] 1x
|--- Offline: [[w0, w1_int8], []] 2.77x
Note:
N1: when w{1,2}_{int8, int16} in [dynamic memory], we do corresponding transform on runtime,
so extra calculation needed.
N2: combine1D2D for 3x3 winograd F(2,3), bottom-right leftover gemm only need (2x2, upper-left) kernel,
so w0 is (2x2)/(3x3) = 0.44x. (int8, combine1D2D, Offline) is 4.4x + 0.44x = 4.84x
2. Calculation load analysis
2.1 weight transformed load
3x3 origin -> 4x4 transformed 2d: oc * ic * (4 * 3 * 3 + 4 * 3 * 4) = oc * ic * 84
3x3 origin -> 2x3x4 transformed 1d: oc * ic * 2 * (4 * 3 * 3) = oc * ic * 72
2.2 combine1D2D saved (when odd height and width)
bottom-right corner: (oc * ic * 4 * 4) - (oc * ic * 2 * 2) = oc * ic * 12
bottom and right 1d unit: N * ((oc * ic * 4 * 4) - (oc * ic * 2 * 4)) = oc * ic * 8 * N, N = H / 2 + W / 2 ~= feature map size
2.3 result
In theory, combine1D2D can speed up execution when N (feature map size) >= 8.
But combine1D2D algorithm is more significant for small feature map.
Now we will not do combine1D2D transform on runtime for simplify (but we may try this in the future).
3. Conclusion
See Fig1 (above figure)
*/
ConvInt83x3::ComputeStrategy ConvInt83x3::getComputeStrategy(const std::vector<Tensor *> &inputs, const std::vector<Tensor *> &outputs) const {
/* TODO: Decide better strategy according to bit-num, max compute on per-cpu core, memory mode in backend config and overral model param.
*/
ComputeStrategy strategy;
int outputCount = outputs[0]->channel(), srcCount = inputs[0]->channel();
int oh = outputs[0]->height(), ow = outputs[0]->width();
int threadNumber = static_cast<CPUBackend*>(backend())->threadNumber();
auto maxMacPerCoreFunc = [=](int unitNum, int blockSize) {
int tileNum = UP_DIV(unitNum, GEMM_TILE_UNIT), tileRemain = tileNum % threadNumber;
int unitRemain = unitNum % GEMM_TILE_UNIT, lastGemmTileUnit = (unitRemain == 0 ? GEMM_TILE_UNIT : unitRemain);
size_t maxMacPerCore = 0;
if (threadNumber == 1) {
maxMacPerCore = ALIMAX(tileNum - 1, 0) * blockSize * GEMM_TILE_UNIT * outputCount * srcCount;
maxMacPerCore += blockSize * lastGemmTileUnit * outputCount * srcCount;
return maxMacPerCore;
}
maxMacPerCore = tileNum / threadNumber * blockSize * GEMM_TILE_UNIT * outputCount * srcCount;
if (tileRemain != 0) {
maxMacPerCore += (tileRemain - 1) * UP_DIV(blockSize, threadNumber) * GEMM_TILE_UNIT * outputCount * srcCount;
maxMacPerCore += UP_DIV(blockSize, threadNumber) * lastGemmTileUnit * outputCount * srcCount;
}
return maxMacPerCore;
};
size_t macOnly2DPerCore = maxMacPerCoreFunc(UP_DIV(oh, DST_UNIT) * UP_DIV(ow, DST_UNIT), BLOCK_UNIT2);
size_t mac1D2DPerCore = 0;
{
int hUnit2D = oh / DST_UNIT, wUnit2D = ow / DST_UNIT;
int hRemain = oh % DST_UNIT, wRemain = ow % DST_UNIT, leftOverPoint = hRemain * wRemain;
mac1D2DPerCore = maxMacPerCoreFunc(hUnit2D * wUnit2D, BLOCK_UNIT2);
mac1D2DPerCore += maxMacPerCoreFunc(hUnit2D * wRemain, BLOCK_UNIT * 3);
mac1D2DPerCore += maxMacPerCoreFunc(wUnit2D * hRemain, BLOCK_UNIT * 3);
mac1D2DPerCore += 9 * leftOverPoint * UP_DIV(outputCount, threadNumber) * srcCount;
}
//MNN_PRINT("macOnly2DPerCore: %lu, mac1D2DPerCore: %lu\n", macOnly2DPerCore, mac1D2DPerCore);
auto memoryMode = static_cast<CPUBackend*>(backend())->memoryMode();
if (mac1D2DPerCore < macOnly2DPerCore && memoryMode == BackendConfig::Memory_High) {
strategy.unitType = ComputeStrategy::D2_D1;
} else {
strategy.unitType = ComputeStrategy::D2;
}
strategy.transPhase = ComputeStrategy::Offline;
return strategy;
}
void ConvInt83x3::weightContent(bool trans2d, bool trans1d) {
const int threadNumber = ((CPUBackend*)backend())->threadNumber();
// winograd weight transform 2d
auto transformWeightFunc = [=](std::shared_ptr<const Tensor> weightOrigin, std::shared_ptr<Tensor> weight) {
const int totalCount = weight->length(1) * weight->length(2); // outputCountUnit * srcCountUnit
const int unitSize = weight->length(3); // unitO(4) * unitI(4 or 8)
const int weightOffset = weight->stride(0);
MNN_CONCURRENCY_BEGIN(tId, threadNumber) {
int step = UP_DIV(totalCount, threadNumber), start = (int)tId * step, end = ALIMIN(start + step, totalCount);
for (int z = start; z < end; ++z) {
auto src = weightOrigin->host<int8_t>() + unitSize * 9 * z;
auto dst = weight->host<int8_t>() + unitSize * z;
weightTransform2D<int8_t, 16>(src, dst, unitSize, weightOffset, unitSize / 16);
}
} MNN_CONCURRENCY_END();
};
// winograd weight transform 1d
auto transformWeightExtraFunc = [=](std::shared_ptr<Tensor> weightOrigin, std::shared_ptr<Tensor> weight) {
const int totalCount = weight->length(2) * weight->length(3); // outputCountUnit * srcCountUnit
const int unitSize = weight->length(4); // unitO(4) * unitI(4 or 8)
const int weightOffset = weight->stride(1);
MNN_CONCURRENCY_BEGIN(tId, threadNumber) {
int step = UP_DIV(totalCount, threadNumber), start = (int)tId * step, end = ALIMIN(start + step, totalCount);
for (int z = start; z < end; ++z) {
auto src = weightOrigin->host<int8_t>() + unitSize * 9 * z;
auto dst = weight->host<int8_t>() + unitSize * z;
for (int i = 0; i < 2 /* instead of 3 */; ++i) { // special case for F(2,3) winograd 1D, only left 3x2 kernel be used.
weightTransform1D<int8_t, 16>(src + i * unitSize, dst + i * BLOCK_UNIT * weightOffset, unitSize * 3, weightOffset, unitSize / 16);
}
dst += weight->stride(0);
for (int i = 0; i < 2 /* instead of 3 */; ++i) { // special case for F(2,3) winograd 1D, only upper 2x3 kernel be used.
weightTransform1D<int8_t, 16>(src + i * 3 * unitSize, dst + i * BLOCK_UNIT * weightOffset, unitSize, weightOffset, unitSize / 16);
}
}
} MNN_CONCURRENCY_END();
};
if (trans2d) {
transformWeightFunc(mWeightInt8, mWeight);
}
if (trans1d) {
transformWeightExtraFunc(mWeightInt8, mWeightExtra);
}
}
ErrorCode ConvInt83x3::tensorMemoryOnStrategyChange(ComputeStrategy* oldStrategy, ComputeStrategy* newStrategy,
const std::vector<Tensor *> &inputs,
const std::vector<Tensor *> &outputs,
std::vector<Tensor *> *dynamicAllocTensors) {
if (oldStrategy == nullptr && newStrategy == nullptr) {
return INVALID_VALUE;
}
if (newStrategy == nullptr) {
backend()->onReleaseBuffer(mWeightInt8.get(), Backend::STATIC);
if (oldStrategy->transPhase != ComputeStrategy::Online) {
backend()->onReleaseBuffer(mWeight.get(), Backend::STATIC);
if (oldStrategy->unitType == ComputeStrategy::D2_D1 && oldStrategy->transPhase == ComputeStrategy::Offline) {
backend()->onReleaseBuffer(mWeightExtra.get(), Backend::STATIC);
}
}
return NO_ERROR;
}
bool trans2d = false, trans1d = false;
// -1 if x is null, 1 if attr of x is equal to ComputeStrategy::value, 0 otherwise.
#define ATTR_CHECK(x, attr, value) (x == nullptr ? -1 : (x->attr == ComputeStrategy::value ? 1 : 0))
int oldTransPhaseIsOnline = ATTR_CHECK(oldStrategy, transPhase, Online);
bool newTransPhaseIsOnline = (newStrategy->transPhase == ComputeStrategy::Online);
#define ALLOC_CHECK(res) if(!(res)) { return OUT_OF_MEMORY; }
if (newTransPhaseIsOnline) {
if (oldTransPhaseIsOnline == 0) {
backend()->onReleaseBuffer(mWeight.get(), Backend::STATIC);
}
dynamicAllocTensors->push_back(mWeight.get());
} else if (!newTransPhaseIsOnline && oldTransPhaseIsOnline != 0) {
ALLOC_CHECK(backend()->onAcquireBuffer(mWeight.get(), Backend::STATIC));
trans2d = true;
}
int oldIsCombine1D2D = ATTR_CHECK(oldStrategy, unitType, D2_D1);
int oldTransPhaseIsOffline = ATTR_CHECK(oldStrategy, transPhase, Offline);
bool newIsCombine1D2D = (newStrategy->unitType == ComputeStrategy::D2_D1);
bool newTransPhaseIsOffline = (newStrategy->transPhase == ComputeStrategy::Offline);
if ((oldIsCombine1D2D == 1 && oldTransPhaseIsOffline == 1) && (!newIsCombine1D2D || !newTransPhaseIsOffline)) {
backend()->onReleaseBuffer(mWeightExtra.get(), Backend::STATIC);
}
if (newIsCombine1D2D) {
// compute shape of mWeightExtra and mWeightLeftOver based on feature map size
auto input = inputs[0], output = outputs[0];
const int kernel = 3, unitI = 8;
int outputCountUnit = UP_DIV(output->channel(), 4), srcCountUnit = UP_DIV(input->channel(), unitI);
int usedKernelX = input->width() - (output->width() / DST_UNIT * DST_UNIT - mPadX);
int usedKernelY = input->height() - (output->height() / DST_UNIT * DST_UNIT - mPadY);
usedKernelX = (usedKernelX == 0 ? kernel : usedKernelX);
usedKernelY = (usedKernelY == 0 ? kernel : usedKernelY);
mWeightExtra.reset(Tensor::createDevice<int8_t>({2, ALIMAX(usedKernelX, usedKernelY) * BLOCK_UNIT, outputCountUnit, srcCountUnit, unitI * 4}));
mWeightLeftOver.reset(Tensor::createDevice<int8_t>({usedKernelX * usedKernelY, outputCountUnit, srcCountUnit, unitI * 4}));
// do memory alloc
if (newTransPhaseIsOffline == 1) {
ALLOC_CHECK(backend()->onAcquireBuffer(mWeightExtra.get(), Backend::STATIC));
trans1d = true;
} else {
dynamicAllocTensors->push_back(mWeightExtra.get());
}
dynamicAllocTensors->push_back(mWeightLeftOver.get());
}
if (trans2d || trans1d) {
weightContent(trans2d, trans1d);
}
return NO_ERROR;
}
ConvInt83x3::ConvInt83x3(Backend *backend, const MNN::Convolution2D *convParam, const std::vector<Tensor *> &inputs,
const std::vector<Tensor *> &outputs) : CPUConvolution(convParam->common(), backend) {
mActBits = convParam->symmetricQuan()->nbits();
if (((CPUBackend*)backend)->memoryMode() == BackendConfig::Memory_High) {
mFixedSimpleStrategy = false;
}
if (mFixedSimpleStrategy) {
mStrategy.unitType = ComputeStrategy::D2;
mStrategy.transPhase = ComputeStrategy::Offline;
}
const auto convCommon = convParam->common();
const auto outputCount = convCommon->outputCount(), srcCount = convCommon->inputCount();
const int unitI = 8, srcCountUnit = UP_DIV(srcCount, unitI), outputCountUnit = UP_DIV(outputCount, 4);
// mWeightInt8 is used to store untransformed reordered weight
mWeightInt8.reset(Tensor::createDevice<int8_t>({UP_DIV(outputCount, 4), UP_DIV(srcCount, unitI), 9, unitI * 4}));
bool allocRes = backend->onAcquireBuffer(mWeightInt8.get(), Backend::STATIC);
const auto weightSrc = convParam->symmetricQuan()->weight()->data();
auto weightDst = mWeightInt8->host<int8_t>();
CPUConvolution::reorderWeightSlow<int8_t>(weightDst, weightSrc, srcCount, outputCount, 9, unitI, 4, true);
// mWeight is used to store 2d-transformed weight
mWeight.reset(Tensor::createDevice<int8_t>({BLOCK_UNIT2, outputCountUnit, srcCountUnit, unitI * 4}));
if (mFixedSimpleStrategy) {
auto code = tensorMemoryOnStrategyChange(nullptr, &mStrategy, inputs, outputs, nullptr);
if (code != NO_ERROR) {
mValid = false;
return;
}
}
const int outputChannleUp4 = ALIGN_UP4(outputCount);
mBiasFloat.reset(Tensor::createDevice<float>({outputChannleUp4}));
auto biasOriginPtr = convParam->symmetricQuan()->bias()->data();
allocRes = CPUConvolution::acquireMemoryAndCopy<int32_t, float>(mBiasFloat, biasOriginPtr, outputCount, backend);
if (!allocRes) {
mValid = false;
return;
}
mScaleFloat.reset(Tensor::createDevice<float>({outputChannleUp4}));
auto scaleOriginData = convParam->symmetricQuan()->scale()->data();
allocRes = CPUConvolution::acquireMemoryAndCopy<float, float>(mScaleFloat, scaleOriginData, outputCount, backend);
if (!allocRes) {
mValid = false;
return;
}
mRelu = convCommon->relu() || convCommon->relu6();
}
ConvInt83x3::~ConvInt83x3() {
tensorMemoryOnStrategyChange(&mStrategy, nullptr, {}, {}, nullptr);
backend()->onReleaseBuffer(mBiasFloat.get(), Backend::STATIC);
backend()->onReleaseBuffer(mScaleFloat.get(), Backend::STATIC);
}
ErrorCode ConvInt83x3::onResize(const std::vector<Tensor *> &inputs, const std::vector<Tensor *> &outputs) {
CPUConvolution::onResize(inputs, outputs);
std::vector<Tensor*> dynamicAllocTensors;
// update mStrategy when tensor size be changed.
if (!mFixedSimpleStrategy) {
auto strategy = getComputeStrategy(inputs, outputs);
//MNN_PRINT("unitType: %d, transPhase: %d\n", strategy.unitType, strategy.transPhase);
auto code = tensorMemoryOnStrategyChange((mStrategyCompleted ? &mStrategy : nullptr), &strategy,
inputs, outputs, &dynamicAllocTensors);
if (code != NO_ERROR) {
mValid = false;
return code;
}
mStrategyCompleted = true;
mStrategy = strategy;
}
const auto srcCount = inputs[0]->channel();
const auto outputCountUnit = UP_DIV(outputs[0]->channel(), 4);
auto threadNums = ((CPUBackend*)backend())->threadNumber();
const bool combine1D2D = (mStrategy.unitType == ComputeStrategy::D2_D1);
int unitI = 8, srcCountUnit = UP_DIV(srcCount, unitI);
const auto height = inputs[0]->height(), width = inputs[0]->width(), batch = inputs[0]->batch();
mTempInput.reset(Tensor::createDevice<int8_t>({batch, srcCountUnit, height, width, unitI}));
mTempSrcBuffer.reset(Tensor::createDevice<int8_t>({threadNums, BLOCK_UNIT2, srcCountUnit, GEMM_TILE_UNIT * unitI}));
mTempDstBuffer.reset(Tensor::createDevice<float>({threadNums, BLOCK_UNIT2, outputCountUnit, GEMM_TILE_UNIT * 4}));
mTempTransformBuffer.reset(Tensor::createDevice<int32_t>({threadNums, 2, SRC_UNIT * SRC_UNIT, 4}));
dynamicAllocTensors.push_back(mTempSrcBuffer.get());
dynamicAllocTensors.push_back(mTempDstBuffer.get());
dynamicAllocTensors.push_back(mTempTransformBuffer.get());
dynamicAllocTensors.push_back(mTempInput.get());
if (combine1D2D) {
mTempOutBuffer.reset(Tensor::createDevice<int32_t>({threadNums, 2, DST_UNIT, outputCountUnit, GEMM_TILE_UNIT * 4}));
dynamicAllocTensors.push_back(mTempOutBuffer.get());
}
// dynamic alloc tensor memory
bool res = true;
for (int i = 0; i < dynamicAllocTensors.size(); ++i) {
res = res && backend()->onAcquireBuffer(dynamicAllocTensors[i], Backend::DYNAMIC);
}
if (!res) {
return OUT_OF_MEMORY;
}
for (int i = 0; i < dynamicAllocTensors.size(); ++i) {
backend()->onReleaseBuffer(dynamicAllocTensors[i], Backend::DYNAMIC);
}
return NO_ERROR;
}
ErrorCode ConvInt83x3::onExecute(const std::vector<Tensor *> &inputs, const std::vector<Tensor *> &outputs) {
auto input = inputs[0];
auto output = outputs[0];
// Clip into [min, max]
const int minVal = -(1<<(mActBits-1)), maxVal = (1<<(mActBits-1))-1, size = inputs[0]->elementSize();
const int threadNumber = ((CPUBackend*)backend())->threadNumber();
auto data = input->host<int8_t>();
MNN_CONCURRENCY_BEGIN(tId, threadNumber) {
int step = UP_DIV(size, 8 * threadNumber), start = (int)tId * step, num = ALIMIN(start + step, size) - start;
if (num > 0) {
MNNInt8ClipInplace(data + start, num, minVal, maxVal);
}
} MNN_CONCURRENCY_END();
const int ow = output->width(), oh = output->height();
const int iw = input->width(), ih = input->height();
const int dc_4 = UP_DIV(output->channel(), 4);
const int padX = mPadX, padY = mPadY;
const bool combine1D2D = (mStrategy.unitType == ComputeStrategy::D2_D1);
const bool offline = (mStrategy.transPhase == ComputeStrategy::Offline);
const bool online = (mStrategy.transPhase == ComputeStrategy::Online);
const int wUnit = (combine1D2D ? ow / DST_UNIT: UP_DIV(ow, DST_UNIT));
const int hUnit = (combine1D2D ? oh / DST_UNIT: UP_DIV(oh, DST_UNIT));
const int unitI = 8, ic_unit = UP_DIV(input->channel(), unitI), weightOffset = mWeight->stride(0);
// weight transform if needed.
bool trans2d = online, trans1d = (combine1D2D && !offline);
if (trans2d || trans1d) {
weightContent(trans2d, trans1d);
}
// C4 to C16 for int8 multype
for (int b = 0; b < input->batch(); ++b) {
auto src = input->host<int8_t>() + b * input->stride(0);
auto dst = mTempInput->host<int8_t>() + b * mTempInput->stride(0);
const int ic8 = UP_DIV(input->channel(), 8), ic4 = UP_DIV(input->channel(), 4);
// C4 to C8
MNN_CONCURRENCY_BEGIN(tId, threadNumber) {
int step = UP_DIV(ic8, threadNumber) * 2, start = (int)tId * step, num = ALIMIN(start + step, ic4) - start;
if (num > 0) {
MNNInt8C4ToC8(dst + start * iw * ih * 8, src + start * iw * ih * 8, iw * ih, num);
}
} MNN_CONCURRENCY_END();
}
auto sourceTransform2DFunc = [=](int xIndex, int xC, const int8_t* srcOrigin, int8_t* srcBlockInt8, int8_t* dstOrigin) {
for (int xi = 0; xi < xC; ++xi) {
auto index = xIndex + xi;
auto dstUnit = dstOrigin + unitI * xi;
int wIndex = index % wUnit, hIndex = index / wUnit;
int srcX = wIndex * DST_UNIT - padX, srcY = hIndex * DST_UNIT - padY;
int sy = ALIMAX(0, srcY) - srcY, ey = ALIMIN(srcY + SRC_UNIT, ih) - srcY;
int sx = ALIMAX(0, srcX) - srcX, ex = ALIMIN(srcX + SRC_UNIT, iw) - srcX;
int xL = ex - sx;
auto srcStart = srcOrigin + (srcX + srcY * iw) * unitI;
for (int z = 0; z < ic_unit; ++z) {
::memset(srcBlockInt8, 0, unitI * SRC_UNIT * SRC_UNIT * sizeof(int8_t));
auto dstStart = dstUnit + z * unitI * xC;
auto src_z = srcStart + z * unitI * iw * ih;
// Extract One Block
if (xL > 0) {
for (int yy = sy; yy < ey; ++yy) {
auto dst_yy = srcBlockInt8 + yy * unitI * SRC_UNIT;
auto src_yy = src_z + unitI * iw * yy;
::memcpy(dst_yy + sx * unitI, src_yy + sx * unitI , xL * unitI * sizeof(int8_t));
}
}
// Source Transform
sourceTransformUnit2D<int8_t, 8>(srcBlockInt8, dstStart, unitI, unitI * xC * ic_unit, 1);
}
}
};
// input tensor right and bottom leftover points
auto sourceTransform1DFunc = [=](int xIndex, int xC, const int8_t* srcOrigin, int8_t* srcBlockInt8,
int8_t* dstOrigin, bool hDirection) -> int {
const int wRemain = ow % DST_UNIT, hBlock = oh / DST_UNIT, wBlock = ow / DST_UNIT, kernel = 3;
// summary used kernel tile (1x3 or 3x1). for example, right and bottom riegon in F(2,3) is 2 instead of 3
int usableKernel = 0;
for (int xi = 0; xi < xC; ++xi) {
auto index = xIndex + xi;
if (hDirection) { // H direction
int srcX = wBlock * DST_UNIT + index % wRemain - padX;
usableKernel = ALIMAX(ALIMIN(srcX + kernel, iw) - srcX, usableKernel);
} else { // W direction
int srcY = hBlock * DST_UNIT + index / wBlock - padY;
usableKernel = ALIMAX(ALIMIN(srcY + kernel, ih) - srcY, usableKernel);
}
}
// do source 1d-winograd transform
for (int xi = 0; xi < xC; ++xi) {
auto dstUnit = dstOrigin + unitI * xi;
auto index = xIndex + xi;
int srcX, srcY, unitX, unitY;
if (hDirection) { // H direction
srcX = wBlock * DST_UNIT + index % wRemain - padX;
srcY = index / wRemain * DST_UNIT - padY;
unitX = kernel;
unitY = SRC_UNIT;
} else { // W direction
srcX = index % wBlock * DST_UNIT - padX;
srcY = hBlock * DST_UNIT + index / wBlock - padY;
unitX = SRC_UNIT;
unitY = kernel;
}
int sx = ALIMAX(0, srcX) - srcX, ex = ALIMIN(srcX + unitX, iw) - srcX;
int sy = ALIMAX(0, srcY) - srcY, ey = ALIMIN(srcY + unitY, ih) - srcY;
int xL = ex - sx;
auto srcStart = srcOrigin + (srcX + srcY * iw) * unitI;
for (int z = 0; z < ic_unit; ++z) {
::memset(srcBlockInt8, 0, unitI * SRC_UNIT * kernel * sizeof(int8_t));
auto dstStart = dstUnit + z * unitI * xC;
auto src_z = srcStart + z * unitI * iw * ih;
// Extract One Block
if (xL > 0) {
for (int yy = sy; yy < ey; ++yy) {
auto dst_yy = srcBlockInt8 + yy * unitI * unitX;
auto src_yy = src_z + unitI * iw * yy;
::memcpy(dst_yy + sx * unitI, src_yy + sx * unitI , xL * unitI * sizeof(int8_t));
}
}
// Source Transform
for (int k = 0; k < usableKernel; ++k) {
int8_t* dst = dstStart + k * unitI * xC * ic_unit * SRC_UNIT;
if (hDirection) {
sourceTransformUnit1D<int8_t, 8>(srcBlockInt8 + unitI * k, dst, kernel * unitI, unitI * xC * ic_unit, 1);
} else {
sourceTransformUnit1D<int8_t, 8>(srcBlockInt8 + unitI * SRC_UNIT * k, dst, unitI, unitI * xC * ic_unit, 1);
}
}
}
}
return usableKernel;
};
auto addBiasAndQuantize = [=](const float* srcOrigin, const float* bias, const float* scale, float* tmpBuffer, int8_t* dstOrigin,
size_t srcStep, size_t count, size_t numBit, bool uint) {
#ifdef MNN_USE_NEON
auto biasV = vld1q_f32(bias);
#endif
for (int j=0; j < count; ++j) {
auto src = srcOrigin + srcStep * j;
auto dst = tmpBuffer + 4 * j;
#ifdef MNN_USE_NEON
vst1q_f32(dst, vld1q_f32(src) + biasV);
#else
for (int k=0; k<4; ++k) {
dst[k] = src[k] + bias[k];
}
#endif
}
ssize_t minValue, maxValue;
if (uint) {
minValue = 0;
maxValue = (1 << numBit) - 1;
} else {
minValue = -(1 << (numBit - 1));
maxValue = (1 << (numBit - 1)) - 1;
}
MNNFloat2Int8(tmpBuffer, dstOrigin, count, scale, minValue, maxValue);
};
auto destTransform2DFunc =
[=, &addBiasAndQuantize](int xIndex, int xC, const float* srcOrigin, const float* bias, const float* scale,
float* dstBlock, int8_t* midBlock, int8_t* dstOrigin) {
// Dest Transform
for (int xi = 0; xi < xC; ++xi) {
auto index = xIndex + xi;
auto srcUnit = srcOrigin + 4 * xi;
int wIndex = index % wUnit, hIndex = index / wUnit;
int dstX = wIndex * DST_UNIT, dstY = hIndex * DST_UNIT;
int dstValidX = ALIMIN(ow - dstX, DST_UNIT), dstValidY = ALIMIN(oh - dstY, DST_UNIT);
auto dstStart = dstOrigin + 4 * (dstX + dstY * ow);
for (int z = 0; z < dc_4; ++z) {
auto srcZ = srcUnit + z * xC * 4;
auto dstZ = dstStart + z * ow * oh * 4;
destTransform2D<WinogradHelper::FractionsInA>(srcZ, dstBlock, dc_4 * 4 * xC, 4, 1);
addBiasAndQuantize(dstBlock, bias + 4 * z, scale + 4 * z, dstBlock, midBlock, 4, DST_UNIT * DST_UNIT, 8, false);
for (int j = 0; j < dstValidY; ++j) {
::memcpy(dstZ + ow * 4 * j, midBlock + (DST_UNIT * j) * 4, 4 * dstValidX * sizeof(int8_t));
}
}
}
};
auto destTransform1DFunc = [=](int xC, const float* srcOrigin, float* dstOrigin) {
// Dest Transform
for (int xi = 0; xi < xC; ++xi) {
auto srcUnit = srcOrigin + 4 * xi;
auto dstStart = dstOrigin + 4 * xi;
for (int z = 0; z < dc_4; ++z) {
auto srcZ = srcUnit + z * xC * 4;
auto dstZ = dstStart + z * xC * 4;
destTransform1D<WinogradHelper::FractionsInA>(srcZ, dstZ, dc_4 * 4 * xC, dc_4 * 4 * xC, 1);
}
}
};
auto outAddBiasQuantizeStore =
[=, &addBiasAndQuantize](int xIndex, int xC, const float* bias, const float* scale, const float* srcOrigin,
int8_t* midBlock, int8_t* dstOrigin, float* tempBuffer, bool hDirection) {
const int wRemain = ow % DST_UNIT, hBlock = oh / DST_UNIT, wBlock = ow / DST_UNIT;
for (int xi = 0; xi < xC; ++xi) {
int index = xIndex + xi;
int dstX, dstY;
if (hDirection) {
dstX = wBlock * DST_UNIT + index % wRemain;
dstY = index / wRemain * DST_UNIT;
} else {
dstX = index % wBlock * DST_UNIT;
dstY = hBlock * DST_UNIT + index / wBlock;
}
auto src_i = srcOrigin + xi * 4;
auto dst_i = dstOrigin + (dstY * ow + dstX) * 4;
for (int z = 0; z < dc_4; ++z) {
auto src_z = src_i + z * xC * 4;
auto dst_z = dst_i + z * oh * ow * 4;
addBiasAndQuantize(src_z, bias + 4 * z, scale + 4 * z, tempBuffer, midBlock, dc_4 * xC * 4, DST_UNIT, 8, false);
if (hDirection) {
for (int i = 0; i < DST_UNIT; ++i) {
::memcpy(dst_z + i * ow * 4, midBlock + i * 4, sizeof(int8_t) * 4);
}
} else {
::memcpy(dst_z, midBlock, DST_UNIT * sizeof(int8_t) * 4);
}
}
}
};
auto gemmFunc = [=](int xC, int start, int end, const int8_t* srcOrigin, const int8_t* weight, float* dstOrigin) {
if (xC == GEMM_TILE_UNIT) {
for (int i = start; i < end; ++i) {
MNNGemmInt8toFloat32_8x4_Unit(dstOrigin + i * dc_4 * 4 * xC, srcOrigin + i * ic_unit * unitI * xC,
weight + i * weightOffset, ic_unit, xC * 4, dc_4);
}
} else {
for (int i = start; i < end; ++i) {
MNNGemmInt8toFloat32_8x4_Common(dstOrigin + i * dc_4 * 4 * xC, srcOrigin + i * ic_unit * unitI * xC,
weight + i * weightOffset, ic_unit, xC, xC * 4, dc_4);
}
}
};
auto gemmConcurrencyFunc = [=, &gemmFunc](int xC, int gemmNum, const int8_t* srcOrigin, const int8_t* weight, float* dstOrigin) {
MNN_CONCURRENCY_BEGIN(tId, threadNumber) {
const int step = UP_DIV(gemmNum, threadNumber);
gemmFunc(xC, (int)tId * step, ALIMIN((tId + 1) * step, gemmNum), srcOrigin, weight, dstOrigin);
}
MNN_CONCURRENCY_END()
};
auto tFunction2D = [&](int tId, int tileStart, int tileStep, int tileEnd, int totalCount,
const int8_t* srcOrigin, int8_t* dstOrigin) {
//MNN_PRINT("tId: %d, tileStart: %d, tileStep: %d, tileEnd: %d, totalCount: %d\n",
// tId, tileStart, tileStep, tileEnd, totalCount);
auto srcBlock = (int8_t*)(mTempTransformBuffer->host<int32_t>() + mTempTransformBuffer->stride(0) * tId);
auto midBlock = (float*)(srcBlock) + mTempTransformBuffer->stride(1);
auto _srcOrigin = mTempSrcBuffer->host<int8_t>() + mTempSrcBuffer->stride(0) * tId;
auto _dstOrigin = mTempDstBuffer->host<float>() + mTempDstBuffer->stride(0) * tId;
for (int tIndex = tileStart; tIndex < tileEnd; tIndex += tileStep) {
int xIndex = (int)tIndex * GEMM_TILE_UNIT;
int xReamin = totalCount - xIndex;
int xC = xReamin > GEMM_TILE_UNIT ? GEMM_TILE_UNIT : xReamin;
sourceTransform2DFunc(xIndex, xC, srcOrigin, srcBlock, _srcOrigin);
if (threadNumber != tileStep) {
gemmConcurrencyFunc(xC, BLOCK_UNIT2, _srcOrigin, mWeight->host<int8_t>(), _dstOrigin);
} else {
gemmFunc(xC, 0, BLOCK_UNIT2, _srcOrigin, mWeight->host<int8_t>(), _dstOrigin);
}
destTransform2DFunc(xIndex, xC, _dstOrigin, mBiasFloat->host<float>(), mScaleFloat->host<float>(),
midBlock, srcBlock, dstOrigin);
}
};
auto tFunction1D = [&](int tId, int tileStart, int tileStep, int tileEnd, int totalCount,
const int8_t* srcOrigin, int8_t* dstOrigin, bool hDirection) {
auto srcBlock = (int8_t*)(mTempTransformBuffer->host<int32_t>() + mTempTransformBuffer->stride(0) * tId);
auto midBlock = (int8_t*)(((int32_t*)srcBlock) + mTempTransformBuffer->stride(1));
auto srcBlockInt8 = midBlock;
auto _srcOrigin = mTempSrcBuffer->host<int8_t>() + mTempSrcBuffer->stride(0) * tId;
auto _dstOriginTemp = mTempDstBuffer->host<float>() + mTempDstBuffer->stride(0) * tId;
float* _dstOrigin[2] = {mTempOutBuffer->host<float>() + mTempOutBuffer->stride(0) * tId, nullptr};
_dstOrigin[1] = _dstOrigin[0] + mTempOutBuffer->stride(1);
const int8_t* weightOrigin = mWeightExtra->host<int8_t>();
if (!hDirection) {
weightOrigin = weightOrigin + mWeightExtra->stride(0);
}
for (int tIndex = tileStart; tIndex < tileEnd; tIndex += tileStep) {
int xIndex = (int)tIndex * GEMM_TILE_UNIT;
int xReamin = totalCount - xIndex;
int xC = xReamin > GEMM_TILE_UNIT ? GEMM_TILE_UNIT : xReamin;
int stride = DST_UNIT * xC * 4;
int usableKernel = sourceTransform1DFunc(xIndex, xC, srcOrigin, srcBlockInt8, _srcOrigin, hDirection);
for (int kIndex = 0; kIndex < usableKernel; ++kIndex) {
const int8_t* weight = weightOrigin + kIndex * BLOCK_UNIT * mWeightExtra->stride(1);
const int8_t* src = _srcOrigin + kIndex * BLOCK_UNIT * ic_unit * xC * unitI;
if (threadNumber != tileStep) {
gemmConcurrencyFunc(xC, BLOCK_UNIT, src, weight, _dstOriginTemp);
} else {
gemmFunc(xC, 0, BLOCK_UNIT, src, weight, _dstOriginTemp);
}
if (kIndex == 0) {
destTransform1DFunc(xC, _dstOriginTemp, _dstOrigin[0]);
} else {
destTransform1DFunc(xC, _dstOriginTemp, _dstOrigin[1]);
MNNMatrixAdd(_dstOrigin[0], _dstOrigin[0], _dstOrigin[1], xC * DST_UNIT, stride, stride, stride, dc_4);
}
}
outAddBiasQuantizeStore(xIndex, xC, mBiasFloat->host<float>(), mScaleFloat->host<float>(),
_dstOrigin[0], midBlock, dstOrigin, (float*)srcBlock, hDirection);
}
};
auto tFunctionLeftOverGemm = [&](const int8_t* srcOrigin, int8_t* dstOrigin) {
auto weightSrc = mWeightInt8->host<int8_t>();
auto weight = mWeightLeftOver->host<int8_t>();
auto src = mTempSrcBuffer->host<int8_t>();
auto dst = mTempDstBuffer->host<float>();
auto tempBuffer = (float*)(dst + dc_4 * 4);
auto dstInt8 = (int8_t*)(dst + 2 * dc_4 * 4);
const int wRemain = ow % DST_UNIT, hRemain = oh % DST_UNIT, kernel = 3;
const int hOffset = oh / DST_UNIT * DST_UNIT, wOffset = ow / DST_UNIT * DST_UNIT;
for (int xi = 0; xi < wRemain * hRemain; ++xi) {
int wIndex = wOffset + xi % wRemain, hIndex = hOffset + xi / wRemain;
int total = 0, cur = 0;
for (int k = 0; k < kernel * kernel; ++k) {
int srcX = wIndex + (k % kernel) - padX, srcY = hIndex + (k / kernel) - padY;
if (srcX >= 0 && srcX < iw && srcY >= 0 && srcY < ih) {
++total;
}
}
for (int k = 0; k < kernel * kernel; ++k) {
int srcX = wIndex + (k % kernel) - padX, srcY = hIndex + (k / kernel) - padY;
if (srcX < 0 || srcX >= iw || srcY < 0 || srcY >= ih) {
continue;
}
for (int zo = 0; zo < dc_4; ++zo) {
for (int zi = 0; zi < ic_unit; ++zi) {
auto weightSrc_ = weightSrc + ((zo * ic_unit + zi) * kernel * kernel + k) * unitI * 4;
auto weight_ = weight + ((zo * total + cur) * ic_unit + zi) * unitI * 4;
::memcpy(weight_, weightSrc_, unitI * 4 * sizeof(int8_t));
}
}
for (int zi = 0; zi < ic_unit; ++zi) {
auto srcOrigin_ = srcOrigin + ((zi * ih + srcY) * iw + srcX) * unitI;
auto src_ = src + (cur * ic_unit + zi) * unitI;
::memcpy(src_, srcOrigin_, unitI * sizeof(int8_t));
}
++cur;
}
MNN_CONCURRENCY_BEGIN(tId, threadNumber) {
const int ocStep = UP_DIV(dc_4, threadNumber);
const int ocStart = ALIMIN(tId * ocStep, dc_4), ocEnd = ALIMIN(ocStart + ocStep, dc_4);
if (ocStart < ocEnd) {
MNNGemmInt8toFloat32_8x4_Common(dst + ocStart * 4, src, weight + ocStart * ic_unit * total * unitI * 4,
ic_unit * total, 1, 4, ocEnd - ocStart);
}
}
MNN_CONCURRENCY_END()
addBiasAndQuantize(dst, mBiasFloat->host<float>(), mScaleFloat->host<float>(), tempBuffer, dstInt8, 4, dc_4, 8, false);
auto dstOrigin_ = dstOrigin + (hIndex * ow + wIndex) * 4;
for (int z = 0; z < dc_4; ++z) {
::memcpy(dstOrigin_ + z * oh * ow * 4, dstInt8 + z * 4, 4 * sizeof(int8_t));
}
}
};
int totalCount, tileCount;
for (int batchIndex = 0; batchIndex < input->batch(); ++batchIndex) {
auto srcOrigin = mTempInput->host<int8_t>() + batchIndex * mTempInput->stride(0);
auto dstOrigin = output->host<int8_t>() + batchIndex * output->stride(0);
// MNN_PRINT("%d, %d, %d, %d\n", wUnit, hUnit, layer->aMin, layer->aMax);
// 2D tile
totalCount = hUnit * wUnit;
tileCount = UP_DIV(totalCount, GEMM_TILE_UNIT);
if (tileCount >= threadNumber) {
MNN_CONCURRENCY_BEGIN(tId, threadNumber) {
tFunction2D((int)tId, (int)tId, threadNumber, tileCount / threadNumber * threadNumber, totalCount, srcOrigin, dstOrigin);
}
MNN_CONCURRENCY_END();
}
if (tileCount % threadNumber != 0) {
tFunction2D(0, tileCount / threadNumber * threadNumber, 1, tileCount, totalCount, srcOrigin, dstOrigin);
}
if (!combine1D2D) {
continue;
}
// 1D tile (H direction)
totalCount = (ow % DST_UNIT) * (oh / DST_UNIT);
tileCount = UP_DIV(totalCount, GEMM_TILE_UNIT);
if (tileCount >= threadNumber) {
MNN_CONCURRENCY_BEGIN(tId, threadNumber) {
tFunction1D((int)tId, (int)tId, threadNumber, tileCount / threadNumber * threadNumber, totalCount, srcOrigin, dstOrigin, true);
}
MNN_CONCURRENCY_END();
}
if (tileCount % threadNumber != 0) {
tFunction1D(0, tileCount / threadNumber * threadNumber, 1, tileCount, totalCount, srcOrigin, dstOrigin, true);
}
// 1D tile (W direction)
totalCount = (oh % DST_UNIT) * (ow / DST_UNIT);
tileCount = UP_DIV(totalCount, GEMM_TILE_UNIT);
if (tileCount >= threadNumber) {
MNN_CONCURRENCY_BEGIN(tId, threadNumber) {
tFunction1D((int)tId, (int)tId, threadNumber, tileCount / threadNumber * threadNumber, totalCount, srcOrigin, dstOrigin, false);
}
MNN_CONCURRENCY_END();
}
if (tileCount % threadNumber != 0) {
tFunction1D(0, tileCount / threadNumber * threadNumber, 1, tileCount, totalCount, srcOrigin, dstOrigin, false);
}
// leftover gemm
tFunctionLeftOverGemm(srcOrigin, dstOrigin);
}
if (mRelu) {
const int dstZStep = ow * oh * 4;
for (int batchIndex = 0; batchIndex < output->batch(); ++batchIndex) {
auto dstOrigin = output->host<int8_t>() + batchIndex * output->stride(0);
MNN_CONCURRENCY_BEGIN(tId, threadNumber) {
for (int z = (int)tId; z < dc_4; z += threadNumber) {
MNNReluInt8(dstOrigin + z * dstZStep, dstOrigin + z * dstZStep, dstZStep);
}
}
MNN_CONCURRENCY_END();
}
}
return NO_ERROR;
}
} /* MNN */
| [
"shuhui.sh@alibaba-inc.com"
] | shuhui.sh@alibaba-inc.com |
0df2d6022d77bc8d1b01c9156d7d729253733c49 | 5ef7f5ba06b98319a5406dfa3b25c985257713d4 | /visa/iga/IGALibrary/Backend/Messages/MessageDecoderLSC.cpp | 3b6ae1e6398c8ca36ccdabb12a48054281a331e9 | [
"MIT"
] | permissive | intel/intel-graphics-compiler | 6a1ae1a84c541e967e70324492f22c941a02e38f | ea522543be6d042ec80e5db8e8878be31af68938 | refs/heads/master | 2023-09-03T20:31:55.215461 | 2023-08-29T18:31:52 | 2023-09-02T08:55:05 | 105,299,467 | 546 | 176 | NOASSERTION | 2023-08-23T08:57:03 | 2017-09-29T17:27:54 | C++ | UTF-8 | C++ | false | false | 41,590 | cpp | /*========================== begin_copyright_notice ============================
Copyright (C) 2020-2021 Intel Corporation
SPDX-License-Identifier: MIT
============================= end_copyright_notice ===========================*/
#include "MessageDecoder.hpp"
#include <utility>
using namespace iga;
enum LscOp : uint32_t {
LSC_LOAD = 0x00,
LSC_LOAD_STRIDED = 0x01,
LSC_LOAD_QUAD = 0x02, // aka load_cmask
LSC_LOAD_BLOCK2D = 0x03,
LSC_STORE = 0x04,
LSC_STORE_STRIDED = 0x05,
LSC_STORE_QUAD = 0x06, // aka store_cmask
LSC_STORE_BLOCK2D = 0x07,
//
LSC_ATOMIC_IINC = 0x08,
LSC_ATOMIC_IDEC = 0x09,
LSC_ATOMIC_LOAD = 0x0A,
LSC_ATOMIC_STORE = 0x0B,
LSC_ATOMIC_IADD = 0x0C,
LSC_ATOMIC_ISUB = 0x0D,
LSC_ATOMIC_SMIN = 0x0E,
LSC_ATOMIC_SMAX = 0x0F,
LSC_ATOMIC_UMIN = 0x10,
LSC_ATOMIC_UMAX = 0x11,
LSC_ATOMIC_ICAS = 0x12,
LSC_ATOMIC_FADD = 0x13,
LSC_ATOMIC_FSUB = 0x14,
LSC_ATOMIC_FMIN = 0x15,
LSC_ATOMIC_FMAX = 0x16,
LSC_ATOMIC_FCAS = 0x17,
LSC_ATOMIC_AND = 0x18,
LSC_ATOMIC_OR = 0x19,
LSC_ATOMIC_XOR = 0x1A,
//
LSC_LOAD_STATUS = 0x1B,
LSC_STORE_UNCOMPRESSED = 0x1C,
LSC_CCS = 0x1D,
//
LSC_RSI = 0x1E,
LSC_FENCE = 0x1F,
//
LSC_STORE_UNCOMPRESSED_QUAD = 0x20,
//
//
LSC_INVALID = 0xFFFFFFFF,
};
static const uint32_t LSC_AT_FLAT = 0x0;
static const uint32_t LSC_AT_BSS = 0x1;
static const uint32_t LSC_AT_SS = 0x2;
static const uint32_t LSC_AT_BTI = 0x3;
static const uint32_t LSC_A16 = 0x1;
static const uint32_t LSC_A32 = 0x2;
static const uint32_t LSC_A64 = 0x3;
static const uint32_t LSC_D8 = 0x0;
static const uint32_t LSC_D16 = 0x1;
static const uint32_t LSC_D32 = 0x2;
static const uint32_t LSC_D64 = 0x3;
static const uint32_t LSC_D8U32 = 0x4;
static const uint32_t LSC_D16U32 = 0x5;
static const uint32_t LSC_D16U32H = 0x6;
static const uint32_t LSC_V1 = 0x0;
static const uint32_t LSC_V2 = 0x1;
static const uint32_t LSC_V3 = 0x2;
static const uint32_t LSC_V4 = 0x3;
static const uint32_t LSC_V8 = 0x4;
static const uint32_t LSC_V16 = 0x5;
static const uint32_t LSC_V32 = 0x6;
static const uint32_t LSC_V64 = 0x7;
const static uint32_t LSC_SCALE_NONE = 0x0;
const static uint32_t LSC_SCALE_1X = 0x1;
const static uint32_t LSC_SCALE_2X = 0x2;
const static uint32_t LSC_SCALE_4X = 0x3;
///////////////////////////////////////////////////////
// Cache Opt
// Value for bits[19:17]
static const uint32_t LSC_DF_DF = 0x0;
//
static const uint32_t LSC_UC_UC = 0x1;
//
static const uint32_t LSC_UC_CA = 0x2;
static const uint32_t LSC_UC_WB = 0x2;
//
static const uint32_t LSC_CA_UC = 0x3;
static const uint32_t LSC_WT_UC = 0x3;
//
static const uint32_t LSC_CA_CA = 0x4;
static const uint32_t LSC_WT_WB = 0x4;
//
static const uint32_t LSC_ST_UC = 0x5;
//
static const uint32_t LSC_ST_CA = 0x6;
static const uint32_t LSC_ST_WB = 0x6;
//
static const uint32_t LSC_RI_CA = 0x7;
static const uint32_t LSC_WB_WB = 0x7;
// Value for bits [19:16]
static const uint32_t LSC_UC_CC = 0x5;
static const uint32_t LSC_CA_CC = 0x9;
static const uint32_t LSC_RI_RI = 0xE;
#if 0
struct LscMessageFormat {
const char *mnemonic;
const char *description;
uint32_t mask;
uint32_t op;
//
// std::pair<Platform,const char *> docs[2];
};
//
static LscMessageFormat OPS[32] {
};
#endif
// This handles LSC messages only
struct MessageDecoderLSC : MessageDecoder {
MessageDecoderLSC(Platform _platform, SFID _sfid, ExecSize _execSize,
SendDesc _exDesc, SendDesc _desc, DecodeResult &_result)
: MessageDecoder(_platform, _sfid, _execSize,
_exDesc, _desc, _result) {
}
// used by decodeLscMessage and subchildren
std::string dataTypePrefixSyntax; // e.g. d32 or d16 or d32
std::string vectorSuffixSyntax; // e.g. x16t (for d16x16t) or .yzw
std::string addrSizeSyntax; // e.g. a32
std::string cacheControlSyntax; // e.g. ca.ca
SendOp op = SendOp::INVALID;
//
int expectedExecSize = 1;
//
int addrSizeBits = 0;
int dataSizeRegBits = 0, dataSizeMemBits = 0;
int vectorSize = 1;
MessageInfo::Attr extraAttrs = MessageInfo::Attr::NONE;
// the symbol to return in the MessageInfo structure
std::string symbolFromSyntax() const {
std::stringstream sym;
sym << result.syntax.mnemonic;
if (!result.syntax.controls.empty())
sym << result.syntax.controls;
sym << " ";
if (!result.syntax.surface.empty())
sym << result.syntax.surface;
sym << "[";
if (!result.syntax.scale.empty()) {
sym << result.syntax.scale;
}
sym << "A";
if (!result.syntax.immOffset.empty()) {
sym << result.syntax.immOffset;
}
sym << "]";
return sym.str();
}
///////////////////////////////////////////////////////////////////////////
void setCacheOpts(std::stringstream &sym, std::stringstream &descs,
CacheOpt &l1, CacheOpt &l3, CacheOpt _l1, CacheOpt _l3) {
l1 = _l1;
l3 = _l3;
if (_l1 == CacheOpt::DEFAULT && _l3 == CacheOpt::DEFAULT) {
descs << "use state settings for both L1 and L3";
return;
}
auto emitCacheOpt = [&](CacheOpt c) {
sym << '.';
switch (c) {
case CacheOpt::DEFAULT:
sym << "df";
descs << " uses default state settings";
break;
case CacheOpt::READINVALIDATE:
sym << "ri";
descs << " read-invalidate (last use)";
break;
case CacheOpt::CACHED:
sym << "ca";
descs << " cached";
break;
case CacheOpt::STREAMING:
sym << "st";
descs << " streaming";
break;
case CacheOpt::UNCACHED:
sym << "uc";
descs << " uncached (bypass)";
break;
case CacheOpt::WRITETHROUGH:
sym << "wt";
descs << " writethrough";
break;
case CacheOpt::WRITEBACK:
sym << "wb";
descs << " writeback";
break;
default:
sym << "?";
descs << " invalid";
break;
}
};
descs << "L1";
emitCacheOpt(_l1);
descs << "; L3";
emitCacheOpt(_l3);
descs << "";
}
void decodeCacheControl(SendOp sop, CacheOpt &l1, CacheOpt &l3) {
if (!decodeLscCacheControlBits17_19(sop, l1, l3))
error(17, 3, "invalid cache options");
}
// Descriptor Bits[19:17]: 3 bits of cache control
bool decodeLscCacheControlBits17_19(SendOp sop, CacheOpt &l1, CacheOpt &l3) {
std::stringstream sym, descs;
l1 = l3 = CacheOpt::DEFAULT;
bool isLoad = lookupSendOp(sop).isLoad();
auto ccBits = getDescBits(17, 3);
auto setCacheOptsWrapper = [&](CacheOpt _l1, CacheOpt _l3) {
return setCacheOpts(sym, descs, l1, l3, _l1, _l3);
};
switch (ccBits) {
case LSC_DF_DF:
setCacheOptsWrapper(CacheOpt::DEFAULT, CacheOpt::DEFAULT);
break;
case LSC_UC_UC:
setCacheOptsWrapper(CacheOpt::UNCACHED, CacheOpt::UNCACHED);
break;
case LSC_UC_CA: // == LSC_UC_WB
if (isLoad)
setCacheOptsWrapper(CacheOpt::UNCACHED, CacheOpt::CACHED);
else
setCacheOptsWrapper(CacheOpt::UNCACHED, CacheOpt::WRITEBACK);
break;
case LSC_CA_UC: // == LSC_WT_UC
if (isLoad)
setCacheOptsWrapper(CacheOpt::CACHED, CacheOpt::UNCACHED);
else
setCacheOptsWrapper(CacheOpt::WRITETHROUGH, CacheOpt::UNCACHED);
break;
case LSC_CA_CA: // == LSC_WT_WB
if (isLoad)
setCacheOptsWrapper(CacheOpt::CACHED, CacheOpt::CACHED);
else
setCacheOptsWrapper(CacheOpt::WRITETHROUGH, CacheOpt::WRITEBACK);
break;
case LSC_ST_UC:
setCacheOptsWrapper(CacheOpt::STREAMING, CacheOpt::UNCACHED);
break;
case LSC_ST_CA: // == LSC_ST_WB
if (isLoad)
setCacheOptsWrapper(CacheOpt::STREAMING, CacheOpt::CACHED);
else
setCacheOptsWrapper(CacheOpt::STREAMING, CacheOpt::WRITEBACK);
break;
case LSC_RI_CA:
if (isLoad) {
// atomic follows store semantics, so compare against load
setCacheOptsWrapper(CacheOpt::READINVALIDATE, CacheOpt::CACHED);
} else {
setCacheOptsWrapper(CacheOpt::WRITEBACK, CacheOpt::WRITEBACK);
}
break;
default:
return false;
}
//
cacheControlSyntax = sym.str();
//
addField("Caching", 17, 3, ccBits, descs.str());
return true;
}
void decodeLscImmOff(uint32_t atBits) {
}
static const int ADDRTYPE_LOC = 29;
AddrType decodeLscAddrType(SendDesc &surfId, bool allowsFlat = true) {
surfId = 0;
AddrType addrType = AddrType::FLAT;
//
const char *addrTypeMeaning = "?";
//
const auto atBits = getDescBits(ADDRTYPE_LOC, 2);
//
std::stringstream surfSyntax;
switch (atBits) {
case LSC_AT_FLAT:
addrTypeMeaning = "Flat";
addrType = AddrType::FLAT;
if (!allowsFlat)
error(ADDRTYPE_LOC, 2, "this message may not use FLAT address type");
break;
case LSC_AT_BSS:
case LSC_AT_SS:
if (atBits == LSC_AT_BSS) {
addrTypeMeaning = "BSS";
addrType = AddrType::BSS;
surfSyntax << "bss";
} else {
addrTypeMeaning = "SS";
addrType = AddrType::SS;
surfSyntax << "ss";
}
if (exDesc.isImm()) {
// XeHPG/XeHPC: we can pull this value out of ExDesc[31:11]
int exDescOff = 11, len = 31 - exDescOff + 1;
surfId = getDescBits(32 + exDescOff, len) << exDescOff;
addField("SurfaceStateOffset", exDescOff, len, surfId.imm,
"immediate surface state offset");
surfSyntax << "[" << iga::fmtHex(surfId.imm) << "]";
} else {
// XeHPG/XeHPC with reg surface state offset
surfSyntax << "[a0." << (int)exDesc.reg.subRegNum << "]";
surfId = exDesc;
}
break;
case LSC_AT_BTI:
addrTypeMeaning = "BTI";
addrType = AddrType::BTI;
if (exDesc.isImm()) {
uint32_t bti = decodeExDescField(
"BTI", 24, 8, [&](std::stringstream &ss, uint32_t bti) {
ss << "bti[" << bti << "]";
});
surfSyntax << "bti[" << bti << "]";
surfId = bti;
} else {
surfSyntax << "bti[a0." << (int)exDesc.reg.subRegNum << "]";
surfId = exDesc;
}
break;
default:
addrTypeMeaning = "INVALID AddrType";
addrType = AddrType::FLAT;
surfSyntax << "?";
error(ADDRTYPE_LOC, 2, "invalid address type");
break;
}
result.syntax.surface = surfSyntax.str();
/////////////////////////////
// immediate offset
decodeLscImmOff(atBits);
//
addField("AddrType", ADDRTYPE_LOC, 2, atBits, addrTypeMeaning);
//
return addrType;
}
void decodeLscAddrSize() {
int addrSzBits = getDescBits(7, 2); // [8:7]
std::stringstream asym;
const char *aDesc = "";
switch (addrSzBits) {
case 1:
asym << "a16";
aDesc = "addresses are 16b";
addrSizeBits = 16;
break;
case 2:
asym << "a32";
aDesc = "addresses are 32b";
addrSizeBits = 32;
break;
case 3:
asym << "a64";
aDesc = "addresses are 64b";
addrSizeBits = 64;
break;
default:
asym << "a???";
aDesc = "address size is invalid";
error(7, 2, "invalid address size");
break;
}
// result.syntax.addressType = ":" + asym.str();
addrSizeSyntax = asym.str();
//
addField("AddrSize", 7, 2, addrSzBits, aDesc);
}
void decodeLscDataSize() {
std::stringstream dsym;
dataSizeRegBits = dataSizeMemBits = 0;
std::string meaning;
auto dtBits = getDescBits(9, 3);
switch (dtBits) { // dat size [11:9]
case LSC_D8:
dataSizeRegBits = dataSizeMemBits = 8;
dsym << "d8";
meaning = "8b per data element";
break;
case LSC_D16:
dataSizeRegBits = dataSizeMemBits = 16;
meaning = "16b per data element";
dsym << "d16";
break;
case LSC_D32:
dataSizeRegBits = dataSizeMemBits = 32;
dsym << "d32";
meaning = "32b per data element";
break;
case LSC_D64:
dataSizeRegBits = dataSizeMemBits = 64;
dsym << "d64";
meaning = "64b per data element";
break;
case LSC_D8U32:
dataSizeRegBits = 32;
dataSizeMemBits = 8;
dsym << "d8u32";
meaning = "load 8b into the low 8b of 32b register elements "
"(upper bits are undefined)";
break;
case LSC_D16U32:
dataSizeRegBits = 32;
dataSizeMemBits = 16;
dsym << "d16u32";
meaning = "load 16b into the low 16b of 32b register elements "
"(upper bits are undefined)";
break;
case LSC_D16U32H:
dataSizeRegBits = 32;
dataSizeMemBits = 16;
extraAttrs |= MessageInfo::Attr::EXPAND_HIGH;
dsym << "d16u32h";
meaning = "load 16b into the high half of 32b register elements";
break;
default:
dsym << "0x" << std::uppercase << std::hex << dtBits;
meaning = "???";
}
//
// result.syntax.dataType = ":" + dsym.str();
dataTypePrefixSyntax = dsym.str();
addField("DataSize", 9, 3, dtBits, meaning);
}
void decodeLscVecSize() {
if (lookupSendOp(op).hasChMask()) {
decodeLscVecSizeQuad();
} else {
decodeLscVecSizeNormal();
}
}
void decodeLscVecSizeNormal() {
std::stringstream vsym;
uint32_t vecSzEncd = getDescBits(12, 3); // [14:12]
switch (vecSzEncd) {
case LSC_V1:
vectorSize = 1;
break;
case LSC_V2:
vectorSize = 2;
break;
case LSC_V3:
vectorSize = 3;
break;
case LSC_V4:
vectorSize = 4;
break;
case LSC_V8:
vectorSize = 8;
break;
case LSC_V16:
vectorSize = 16;
break;
case LSC_V32:
vectorSize = 32;
break;
case LSC_V64:
vectorSize = 64;
break;
default:
vsym << "x?";
}
bool opIsBlock2d =
op == SendOp::LOAD_BLOCK2D || op == SendOp::STORE_BLOCK2D;
auto transposed = decodeDescBitField(
"DataOrder", 15,
"non-transposed (vector elements are in successive registers)",
"transposed (vector elements are in the same register)");
if (vectorSize > 1 || transposed && !opIsBlock2d) {
vsym << 'x' << vectorSize;
}
if (transposed && op == SendOp::LOAD_STATUS) {
error(15, 1, "data order must be non-transposed for this op");
}
std::stringstream vdesc;
vdesc << "each address accesses " << vectorSize << " element";
if (vectorSize != 1)
vdesc << "s";
if (!opIsBlock2d)
addField("VecSize", 12, 3, vecSzEncd, vdesc.str());
if (transposed) {
vsym << 't';
extraAttrs |= MessageInfo::Attr::TRANSPOSED;
expectedExecSize = 1; // all transpose messages are SIMD1
}
if (op == SendOp::LOAD_BLOCK2D) {
bool vnni =
decodeDescBitField("Block2dVnniTransform", 7, "disabled", "enabled");
if (vnni)
vsym << 'v';
}
vectorSuffixSyntax = vsym.str();
}
void decodeLscVecSizeQuad() {
// LSC channels *enabled* is the inverse of the old messages
// because the old ChMask used in untyped old (scatter4/gather4)
// was really a channel "disable" mask
auto chEn = getDescBits(12, 4);
vectorSize = 0;
for (int i = 0; i < 4; ++i) {
if ((1 << i) & chEn) {
vectorSize++;
}
}
extraAttrs |= MessageInfo::Attr::HAS_CHMASK;
std::stringstream vsym;
vsym << ".";
if (chEn & 1)
vsym << "x";
if (chEn & 2)
vsym << "y";
if (chEn & 4)
vsym << "z";
if (chEn & 8)
vsym << "w";
vectorSuffixSyntax = vsym.str();
addField("CompEn", 12, 4, chEn, vsym.str());
}
///////////////////////////////////////////////////////////////////////////
void decodeLscMessage(const char *doc, std::string msgDesc, SendOp lscOp) {
const std::string symbol = ToSyntax(lscOp);
op = lscOp;
const SendOpDefinition &opInfo = lookupSendOp(lscOp);
bool opSupportsUvr = lscOp == SendOp::LOAD_QUAD ||
lscOp == SendOp::STORE_QUAD ||
lscOp == SendOp::STORE_UNCOMPRESSED_QUAD ||
opInfo.isAtomic();
if (sfid == SFID::TGM && opSupportsUvr) {
extraAttrs |= MessageInfo::Attr::HAS_UVRLOD;
}
addField("Opcode", 0, 6, getDescBits(0, 6), symbol);
setDoc(doc);
//
if (exDesc.isImm() && (exDesc.imm & 0x7FF)) {
// bit 11 may or may not be available
error(0, 12, "ExDesc[11:0] must be 0 on this platform");
}
//
SendDesc surfaceId(0x0);
AddrType addrType = decodeLscAddrType(surfaceId);
//
if (op == SendOp::LOAD_BLOCK2D || op == SendOp::STORE_BLOCK2D) {
addrSizeBits = 64;
addrSizeSyntax = "a64";
} else {
decodeLscAddrSize();
}
//
decodeLscDataSize();
//
expectedExecSize = op == SendOp::LOAD_BLOCK2D || op == SendOp::STORE_BLOCK2D
? 1
: sfid == SFID::TGM ? DEFAULT_EXEC_SIZE / 2
: DEFAULT_EXEC_SIZE;
decodeLscVecSize();
//
if (sfid == SFID::TGM)
extraAttrs |= MessageInfo::Attr::TYPED;
if (sfid == SFID::SLM)
extraAttrs |= MessageInfo::Attr::SLM;
//
CacheOpt l1 = CacheOpt::DEFAULT, l3 = CacheOpt::DEFAULT;
bool hasCc = opInfo.isLoad() || opInfo.isStore() || opInfo.isAtomic();
if (sfid != SFID::SLM && hasCc) {
decodeCacheControl(op, l1, l3);
}
//
result.syntax.mnemonic = symbol;
//
result.syntax.controls += '.';
result.syntax.controls += dataTypePrefixSyntax;
result.syntax.controls += vectorSuffixSyntax;
if (!addrSizeSyntax.empty()) {
result.syntax.controls += '.';
result.syntax.controls += addrSizeSyntax;
}
if (!cacheControlSyntax.empty()) {
result.syntax.controls += cacheControlSyntax;
}
//
setScatterGatherOpX(symbolFromSyntax(), msgDesc, op, addrType, surfaceId,
l1, l3, addrSizeBits, dataSizeRegBits, dataSizeMemBits,
vectorSize, int(instExecSize), extraAttrs);
if (lookupSendOp(op).hasChMask()) {
result.info.channelsEnabled = getDescBits(12, 4);
if (result.info.channelsEnabled == 0)
error(12, 4, "no channels enabled on quad message");
}
}
void setLscAtomicMessage(const char *doc, std::string msgDesc, SendOp atOp) {
extraAttrs |= getDescBits(20, 5) != 0 ? MessageInfo::Attr::ATOMIC_RETURNS
: MessageInfo::Attr::NONE;
if (sfid == SFID::TGM)
extraAttrs |= MessageInfo::Attr::HAS_UVRLOD;
decodeLscMessage(doc, msgDesc, atOp);
}
void tryDecodeLsc() {
int lscOp = getDescBits(0, 6); // Opcode[5:0]
switch (lscOp) {
case LSC_LOAD:
decodeLscMessage(chooseDoc(nullptr, "53523", "63970"), "gathering load",
SendOp::LOAD);
break;
case LSC_STORE:
decodeLscMessage(chooseDoc(nullptr, "53523", "63980"), "scattering store",
SendOp::STORE);
break;
case LSC_STORE_UNCOMPRESSED:
decodeLscMessage(chooseDoc(nullptr, "53532", "63984"),
"scattering store uncompressed",
SendOp::STORE_UNCOMPRESSED);
break;
case LSC_STORE_UNCOMPRESSED_QUAD:
decodeLscMessage(chooseDoc(nullptr, "55224", "63985"),
"store quad uncompressed",
SendOp::STORE_UNCOMPRESSED_QUAD);
break;
case LSC_LOAD_QUAD:
decodeLscMessage(chooseDoc(nullptr, "53527", "63977"),
"quad load (a.k.a. load_cmask)", SendOp::LOAD_QUAD);
break;
case LSC_STORE_QUAD:
decodeLscMessage(chooseDoc(nullptr, "53527", "63983"),
"quad store (a.k.a. store_cmask)", SendOp::STORE_QUAD);
break;
case LSC_LOAD_STRIDED:
decodeLscMessage(chooseDoc(nullptr, "53525", "63976"),
"strided load (a.k.a load_block)", SendOp::LOAD_STRIDED);
break;
case LSC_STORE_STRIDED:
decodeLscMessage(chooseDoc(nullptr, "53526", "63982"),
"strided store (a.k.a store_block)",
SendOp::STORE_STRIDED);
break;
case LSC_LOAD_BLOCK2D:
decodeLscMessage(chooseDoc(nullptr, "53680", "63972"), "block2d load",
SendOp::LOAD_BLOCK2D);
break;
case LSC_STORE_BLOCK2D:
decodeLscMessage(chooseDoc(nullptr, "53530", "63981"), "block2d store",
SendOp::STORE_BLOCK2D);
break;
case LSC_ATOMIC_IINC:
setLscAtomicMessage(chooseDoc(nullptr, "53538", "63955"),
"atomic integer increment", SendOp::ATOMIC_IINC);
break;
case LSC_ATOMIC_IDEC:
setLscAtomicMessage(chooseDoc(nullptr, "53539", "63949"),
"atomic integer decrement", SendOp::ATOMIC_IDEC);
break;
case LSC_ATOMIC_LOAD:
setLscAtomicMessage(chooseDoc(nullptr, "53540", "63956"), "atomic load",
SendOp::ATOMIC_LOAD);
break;
case LSC_ATOMIC_STORE:
setLscAtomicMessage(chooseDoc(nullptr, "53541", "63960"), "atomic store",
SendOp::ATOMIC_STORE);
break;
case LSC_ATOMIC_IADD:
setLscAtomicMessage(chooseDoc(nullptr, "53542", "63946"),
"atomic integer add", SendOp::ATOMIC_IADD);
break;
case LSC_ATOMIC_ISUB:
setLscAtomicMessage(chooseDoc(nullptr, "53543", "63961"),
"atomic integer subtract", SendOp::ATOMIC_ISUB);
break;
case LSC_ATOMIC_SMIN:
setLscAtomicMessage(chooseDoc(nullptr, "53544", "63958"),
"atomic signed-integer minimum", SendOp::ATOMIC_SMIN);
break;
case LSC_ATOMIC_SMAX:
setLscAtomicMessage(chooseDoc(nullptr, "53545", "63957"),
"atomic signed-integer maximum", SendOp::ATOMIC_SMAX);
break;
case LSC_ATOMIC_UMIN:
setLscAtomicMessage(chooseDoc(nullptr, "53546", "63963"),
"atomic unsigned-integer minimum",
SendOp::ATOMIC_UMIN);
break;
case LSC_ATOMIC_UMAX:
setLscAtomicMessage(chooseDoc(nullptr, "53547", "63962"),
"atomic unsigned-integer maximum",
SendOp::ATOMIC_UMAX);
break;
case LSC_ATOMIC_ICAS:
setLscAtomicMessage(chooseDoc(nullptr, "53555", "63948"),
"atomic integer compare and swap",
SendOp::ATOMIC_ICAS);
break;
case LSC_ATOMIC_FADD:
setLscAtomicMessage(chooseDoc(nullptr, "53548", "63950"),
"atomic float add", SendOp::ATOMIC_FADD);
break;
case LSC_ATOMIC_FSUB:
setLscAtomicMessage(chooseDoc(nullptr, "53549", "63954"),
"atomic float subtract", SendOp::ATOMIC_FSUB);
break;
case LSC_ATOMIC_FMIN:
setLscAtomicMessage(chooseDoc(nullptr, "53550", "63953"),
"atomic float minimum", SendOp::ATOMIC_FMIN);
break;
case LSC_ATOMIC_FMAX:
setLscAtomicMessage(chooseDoc(nullptr, "53551", "63952"),
"atomic float maximum", SendOp::ATOMIC_FMAX);
break;
case LSC_ATOMIC_FCAS:
setLscAtomicMessage(chooseDoc(nullptr, "53556", "63951"),
"atomic float compare and swap", SendOp::ATOMIC_FCAS);
break;
case LSC_ATOMIC_AND:
setLscAtomicMessage(chooseDoc(nullptr, "53552", "63947"),
"atomic logical and", SendOp::ATOMIC_AND);
break;
case LSC_ATOMIC_OR:
setLscAtomicMessage(chooseDoc(nullptr, "53553", "63959"),
"atomic logical or", SendOp::ATOMIC_OR);
break;
case LSC_ATOMIC_XOR:
setLscAtomicMessage(chooseDoc(nullptr, "53554", "63964"),
"atomic logical xor", SendOp::ATOMIC_XOR);
break;
case LSC_CCS:
decodeLscCcs();
break;
case LSC_RSI: {
addField("Opcode", 0, 6, getDescBits(0, 6), "read_state");
setDoc(nullptr, "54000", "63979");
//
std::stringstream descs;
descs << "read state information";
result.syntax.mnemonic = "read_state";
//
SendDesc surfId = 0;
auto at = decodeLscAddrType(surfId, false);
//
// XeHPG returns 2 GRF, XeHPC+ only 1
// #54152
int rlen = platform() == Platform::XE_HPG ? 2 : 1;
setSpecialOpX(result.syntax.mnemonic, descs.str(), SendOp::READ_STATE, at,
surfId,
1, // mlen = 1 (U,V,R,LOD)
rlen);
result.info.addrSizeBits = 64;
result.info.execWidth = 1;
result.info.attributeSet |= MessageInfo::Attr::HAS_UVRLOD;
result.info.attributeSet |= MessageInfo::Attr::TRANSPOSED;
break;
}
case LSC_FENCE:
decodeLscFence();
break;
case LSC_LOAD_STATUS:
if (getDescBit(15)) {
error(15, 1, "transpose forbidden on load_status");
}
if (getDescBits(20, 5) != 1) {
error(20, 5, "load_status must have rlen (Desc[24:20] == 1)");
}
decodeLscMessage(chooseDoc(nullptr, "53531", "63978"), "load status",
SendOp::LOAD_STATUS);
break;
default:
addField("Opcode", 0, 6, getDescBits(0, 6), "invalid message opcode");
error(0, 6, "unsupported message opcode");
return;
}
}
void decodeLscCcs() {
addField("Opcode", 0, 6, static_cast<uint32_t>(LSC_CCS),
"compression-state control");
//
std::stringstream descs;
result.syntax.mnemonic = "ccs";
descs << "compression-state control";
auto ccsOpBits = getDescBits(17, 3);
SendOp sop = SendOp::INVALID;
std::string opDesc;
switch (ccsOpBits) {
case 0:
sop = SendOp::CCS_PC;
result.syntax.mnemonic += "_pc";
opDesc = " page clear (64k)";
setDoc(nullptr, "53536", "63965");
break;
case 1:
sop = SendOp::CCS_SC;
result.syntax.mnemonic += "_sc";
opDesc = " sector clear (2-cachelines)";
setDoc(nullptr, "53534", "63967");
result.syntax.controls += vectorSuffixSyntax;
break;
case 2:
sop = SendOp::CCS_PU;
result.syntax.mnemonic += "_pu";
opDesc = " page uncompress (64k)";
setDoc(nullptr, "53537", "63966");
break;
case 3:
sop = SendOp::CCS_SU;
result.syntax.mnemonic += "_su";
opDesc = " sector uncompress (2-cachelines)";
setDoc(nullptr, "53535", "63968");
result.syntax.controls += vectorSuffixSyntax;
break;
default: {
std::stringstream ss;
ss << ".0x" << std::hex << std::uppercase << ccsOpBits;
result.syntax.controls += ss.str();
opDesc = "invalid ccs sop";
error(17, 3, "invalid ccs sop");
}
} // switch
descs << opDesc;
//
addField("CcsOp", 17, 3, ccsOpBits, opDesc);
//
SendDesc surfId = 0;
auto at = decodeLscAddrType(surfId);
if (ccsOpBits == 0 || ccsOpBits == 2) {
// page operations: pc, pu
if (at != AddrType::FLAT)
error(29, 2, "ccs_{pcc,pcu} requires FLAT address type");
std::stringstream dummy;
decodeLscAddrSize();
if (addrSizeBits != 64)
error(7, 2, "AddrSize must be A64");
result.info.execWidth = 1;
expectedExecSize = 1;
// sector uncompress has addresses
// FIXME: I could derive this via exec size and a64
int mlen =
ccsOpBits == 1 || ccsOpBits == 3 ? 4 : // A64_PAYLOAD_SIMT32 = 4 regs
1; // A64_PAYLOAD_SIMT1 = 1 reg
int rlen = 0; // always 0
setSpecialOpX(symbolFromSyntax(), descs.str(), sop, at, surfId, mlen,
rlen);
} else {
// sector operations
///
// these are vector messages
expectedExecSize = DEFAULT_EXEC_SIZE;
// const int SECTOR_SIZE_BITS = 128*8;
// result.syntax.controls += ".d1024";
result.syntax.controls += vectorSuffixSyntax;
result.syntax.controls += addrSizeBits == 64 ? ".a64" : ".a32";
//
setScatterGatherOp(symbolFromSyntax(), descs.str(), sop, at, surfId,
addrSizeBits,
0, // dateSize = 0; nothing returned
vectorSize, DEFAULT_EXEC_SIZE, extraAttrs);
}
}
void decodeLscFence() {
addField("Opcode", 0, 6, getDescBits(0, 6), "fence");
setDoc(nullptr, "53533", "63969");
//
std::stringstream descs;
result.syntax.mnemonic = "fence";
descs << "fence";
//
std::stringstream fenceOpts;
addLscFenceFields(fenceOpts, descs);
result.syntax.controls += fenceOpts.str();
//
setSpecialOpX(symbolFromSyntax(), descs.str(), SendOp::FENCE,
AddrType::FLAT,
0, // no surface
1, // mlen = 1
0); // rlen = 0
}
}; // MessageDecoderLSC
void iga::decodeDescriptorsLSC(Platform platform, SFID sfid, ExecSize execSize,
SendDesc exDesc, SendDesc desc,
DecodeResult &result) {
MessageDecoderLSC md(platform, sfid, execSize,
exDesc, desc, result);
md.tryDecodeLsc();
}
// descriptor bits [19:17]: cache control
static bool encLdStVecCachingBits17_19(SendOp op, CacheOpt cachingL1,
CacheOpt cachingL3, SendDesc &desc) {
const auto &opInfo = lookupSendOp(op);
bool isLd = opInfo.isLoad();
bool isSt = opInfo.isStore();
bool isAt = opInfo.isAtomic();
bool isStAt = isSt || isAt;
auto ccMatches = [&](CacheOpt l1, CacheOpt l3, uint32_t enc) {
if (l1 == cachingL1 && l3 == cachingL3) {
desc.imm |= enc << 17;
return true;
}
return false;
};
bool matched =
ccMatches(CacheOpt::DEFAULT, CacheOpt::DEFAULT, LSC_DF_DF) ||
//
ccMatches(CacheOpt::UNCACHED, CacheOpt::UNCACHED, LSC_UC_UC) ||
//
(isLd && ccMatches(CacheOpt::UNCACHED, CacheOpt::CACHED, LSC_UC_CA)) ||
(isStAt &&
ccMatches(CacheOpt::UNCACHED, CacheOpt::WRITEBACK, LSC_UC_WB)) ||
//
(isLd && ccMatches(CacheOpt::CACHED, CacheOpt::UNCACHED, LSC_CA_UC)) ||
(isSt &&
ccMatches(CacheOpt::WRITETHROUGH, CacheOpt::UNCACHED, LSC_WT_UC)) ||
//
(isLd && ccMatches(CacheOpt::CACHED, CacheOpt::CACHED, LSC_CA_CA)) ||
(isSt &&
ccMatches(CacheOpt::WRITETHROUGH, CacheOpt::WRITEBACK, LSC_WT_WB)) ||
//
ccMatches(CacheOpt::STREAMING, CacheOpt::UNCACHED, LSC_ST_UC) ||
//
(isLd && ccMatches(CacheOpt::STREAMING, CacheOpt::CACHED, LSC_ST_CA)) ||
(isSt &&
ccMatches(CacheOpt::STREAMING, CacheOpt::WRITEBACK, LSC_ST_WB)) ||
//
(isLd &&
ccMatches(CacheOpt::READINVALIDATE, CacheOpt::CACHED, LSC_RI_CA)) ||
(isSt && ccMatches(CacheOpt::WRITEBACK, CacheOpt::WRITEBACK, LSC_WB_WB));
return matched;
}
static bool encLdStVecCaching(const Platform &p, SendOp op, CacheOpt cachingL1,
CacheOpt cachingL3, SendDesc &desc) {
return encLdStVecCachingBits17_19(op, cachingL1, cachingL3, desc);
}
static bool encLdStVec(Platform p, const VectorMessageArgs &vma,
SendDesc &exDesc, SendDesc &desc, std::string &err) {
desc = 0x0;
exDesc = 0x0;
//
bool hasCMask = false;
switch (vma.op) {
case SendOp::LOAD:
desc.imm |= LSC_LOAD;
break;
case SendOp::LOAD_STRIDED:
desc.imm |= LSC_LOAD_STRIDED;
break;
case SendOp::LOAD_QUAD:
desc.imm |= LSC_LOAD_QUAD;
hasCMask = true;
break;
case SendOp::LOAD_BLOCK2D:
desc.imm |= LSC_LOAD_BLOCK2D;
break;
//
case SendOp::STORE:
desc.imm |= LSC_STORE;
break;
case SendOp::STORE_STRIDED:
desc.imm |= LSC_STORE_STRIDED;
break;
case SendOp::STORE_QUAD:
desc.imm |= LSC_STORE_QUAD;
hasCMask = true;
break;
case SendOp::STORE_UNCOMPRESSED:
desc.imm |= LSC_STORE_UNCOMPRESSED;
break;
case SendOp::STORE_UNCOMPRESSED_QUAD:
desc.imm |= LSC_STORE_UNCOMPRESSED_QUAD;
hasCMask = true;
break;
case SendOp::STORE_BLOCK2D:
desc.imm |= LSC_STORE_BLOCK2D;
break;
//
case SendOp::ATOMIC_AND:
desc.imm |= LSC_ATOMIC_AND;
break;
case SendOp::ATOMIC_FADD:
desc.imm |= LSC_ATOMIC_FADD;
break;
case SendOp::ATOMIC_FCAS:
desc.imm |= LSC_ATOMIC_FCAS;
break;
case SendOp::ATOMIC_FMAX:
desc.imm |= LSC_ATOMIC_FMAX;
break;
case SendOp::ATOMIC_FMIN:
desc.imm |= LSC_ATOMIC_FMIN;
break;
case SendOp::ATOMIC_FSUB:
desc.imm |= LSC_ATOMIC_FSUB;
break;
case SendOp::ATOMIC_IADD:
desc.imm |= LSC_ATOMIC_IADD;
break;
case SendOp::ATOMIC_ICAS:
desc.imm |= LSC_ATOMIC_ICAS;
break;
case SendOp::ATOMIC_IDEC:
desc.imm |= LSC_ATOMIC_IDEC;
break;
case SendOp::ATOMIC_IINC:
desc.imm |= LSC_ATOMIC_IINC;
break;
case SendOp::ATOMIC_ISUB:
desc.imm |= LSC_ATOMIC_ISUB;
break;
case SendOp::ATOMIC_LOAD:
desc.imm |= LSC_ATOMIC_LOAD;
break;
case SendOp::ATOMIC_OR:
desc.imm |= LSC_ATOMIC_OR;
break;
case SendOp::ATOMIC_SMAX:
desc.imm |= LSC_ATOMIC_SMAX;
break;
case SendOp::ATOMIC_SMIN:
desc.imm |= LSC_ATOMIC_SMIN;
break;
case SendOp::ATOMIC_STORE:
desc.imm |= LSC_ATOMIC_STORE;
break;
case SendOp::ATOMIC_UMAX:
desc.imm |= LSC_ATOMIC_UMAX;
break;
case SendOp::ATOMIC_UMIN:
desc.imm |= LSC_ATOMIC_UMIN;
break;
case SendOp::ATOMIC_XOR:
desc.imm |= LSC_ATOMIC_XOR;
break;
default:
err = "unsupported op";
return false;
}
bool isBlock2d =
vma.op == SendOp::LOAD_BLOCK2D || vma.op == SendOp::STORE_BLOCK2D;
bool isBlock2dTyped = isBlock2d && vma.sfid == SFID::TGM;
bool isBlock2dUntyped = isBlock2d && vma.sfid != SFID::TGM;
bool hasAddrSizeField = !isBlock2d;
//
////////////////////////////////////////
// data size
uint32_t dszEnc = LSC_D8;
if (isBlock2dTyped && (vma.dataSizeReg != 32 || vma.dataSizeMem != 32)) {
err = "block2d.tgm must be d32";
return false;
}
if (vma.dataSizeMem == vma.dataSizeReg) {
switch (vma.dataSizeMem) {
case 8:
dszEnc = LSC_D8;
break;
case 16:
dszEnc = LSC_D16;
break;
case 32:
dszEnc = LSC_D32;
break;
case 64:
dszEnc = LSC_D64;
break;
default:
err = "invalid data size";
return false;
}
} else if (vma.dataSizeMem == 8 && vma.dataSizeReg == 32) {
dszEnc = LSC_D8U32;
} else if (vma.dataSizeMem == 16 && vma.dataSizeReg == 32) {
if (vma.dataSizeExpandHigh) {
dszEnc = LSC_D16U32H;
} else {
dszEnc = LSC_D16U32;
}
} else {
err = "invalid data type";
return false;
}
if (!isBlock2dTyped)
desc.imm |= dszEnc << 9;
//
////////////////////////////////////////
// vector size
if (hasCMask) {
if (vma.dataComponentMask & ~0xF) {
err = "invalid component mask";
return false;
}
desc.imm |= vma.dataComponentMask << 12;
} else if (isBlock2d) {
if (isBlock2dTyped && vma.dataVnni) {
err = "block2d.tgm forbids VNNI";
return false;
} else if (isBlock2dTyped && vma.dataTranspose) {
err = "block2d.tgm forbids transpose data order";
return false;
}
if (vma.dataVnni)
desc.imm |= 1 << 7;
if (vma.dataTranspose)
desc.imm |= 1 << 15;
} else {
uint32_t vecEnc = LSC_V1;
switch (vma.dataVectorSize) {
case 1:
vecEnc = LSC_V1;
break;
case 2:
vecEnc = LSC_V2;
break;
case 3:
vecEnc = LSC_V3;
break;
case 4:
vecEnc = LSC_V4;
break;
case 8:
vecEnc = LSC_V8;
break;
case 16:
vecEnc = LSC_V16;
break;
case 32:
vecEnc = LSC_V32;
break;
case 64:
vecEnc = LSC_V64;
break;
default:
err = "invalid vector size";
break;
}
if (vma.isAtomic() && vma.dataVectorSize != 1) {
err = "atomics do not support vector operations";
return false;
}
if (vma.dataVnni) {
err = "vnni only valid on block2d operations";
return false;
}
//
desc.imm |= vecEnc << 12;
//
if (vma.dataTranspose) {
desc.imm |= 1 << 15;
//
if (vma.isAtomic()) {
err = "atomics do not support transpose operations";
return false;
}
}
} // end vec non-cmask case
//
////////////////////////////////////////
// caching options
if (vma.isAtomic() && vma.cachingL1 != CacheOpt::DEFAULT &&
vma.cachingL1 != CacheOpt::UNCACHED) {
err = "atomic L1 must be an uncached option";
return false;
} else {
if (!encLdStVecCaching(p, vma.op, vma.cachingL1, vma.cachingL3, desc)) {
err = "invalid cache-control combination";
return false;
}
}
//
////////////////////////////////////////
// address size
uint32_t asEnc = 0x0;
switch (vma.addrSize) {
case 16:
asEnc = LSC_A16;
break;
case 32:
asEnc = LSC_A32;
break;
case 64:
asEnc = LSC_A64;
break;
default:
err = "unsupported address size";
return false;
}
if (isBlock2dTyped && vma.addrSize != 32) {
err = "block2d.typed address size must be A32";
return false;
}
if (isBlock2dUntyped && vma.addrSize != 64) {
err = "block2d untyped address size must be A64";
return false;
}
if (hasAddrSizeField) {
desc.imm |= asEnc << 7;
}
//
////////////////////////////////////////
// address type
uint32_t atEnc = 0x0;
switch (vma.addrType) {
case AddrType::FLAT:
atEnc = LSC_AT_FLAT;
break;
case AddrType::BSS:
atEnc = LSC_AT_BSS;
break;
case AddrType::SS:
atEnc = LSC_AT_SS;
break;
case AddrType::BTI:
atEnc = LSC_AT_BTI;
break;
default:
err = "unsupported address type";
return false;
}
if (isBlock2dTyped && vma.addrType == AddrType::FLAT) {
err = "block2d.typed forbids flat address";
return false;
}
desc.imm |= atEnc << 29;
//
// store the surface
if (vma.addrType != AddrType::FLAT) {
// use exDesc
if (vma.addrType == AddrType::BTI && !vma.addrSurface.isReg()) {
exDesc = vma.addrSurface.imm << 24;
} else {
exDesc = vma.addrSurface;
}
}
//
if (vma.addrType != AddrType::FLAT && vma.sfid == SFID::SLM) {
err = "SLM requires flat address type";
return false;
}
////////////////////////////////////////
// address scale factor
if (vma.addrScale != 1) {
if (true) { // disable if address scaling is ever added
err = "address scaling not supported on this platform";
return false;
}
int vlen = vma.elementsPerAddress();
int bytesPerElem = vma.dataSizeMem * vlen / 8;
uint32_t addrScEnc = LSC_SCALE_NONE;
if (vma.addrScale > 32) {
err = "scale value is too large";
return false;
} else if (vma.addrScale == bytesPerElem) {
addrScEnc = LSC_SCALE_1X;
} else if (vma.addrScale == 2 * bytesPerElem) {
addrScEnc = LSC_SCALE_2X;
} else if (vma.addrScale == 4 * bytesPerElem) {
addrScEnc = LSC_SCALE_4X;
} else {
std::stringstream ss;
ss << "invalid scaling factor (must be " << 1 * bytesPerElem << ", "
<< 2 * bytesPerElem << ", or " << 4 * bytesPerElem << ")";
err = ss.str();
return false;
}
desc.imm |= addrScEnc << 22;
}
//
////////////////////////////////////////
// address immediate offset
bool hasAddrImmOffset = vma.addrOffset != 0;
hasAddrImmOffset |= vma.addrOffsetX != 0;
hasAddrImmOffset |= vma.addrOffsetY != 0;
if (hasAddrImmOffset) {
bool platformSupportsAddrOff = false;
if (platformSupportsAddrOff) {
err = "address immediate offset not supported on this platform";
return false;
}
} // else: addrOffset == 0
////////////////////////////////////////
// set the surface object
if (vma.addrType == AddrType::FLAT) {
// IR normalization
if (!vma.addrSurface.isImm() || vma.addrSurface.imm != 0) {
err = "malformed IR: flat address model must have surface = 0";
return false;
}
}
// XeHPG+ have surface in ExDesc
if (vma.addrType == AddrType::BTI && vma.addrSurface.isImm()) {
// BTI takes the high byte
if (vma.addrSurface.imm > 0xFF) {
err = "surface index too large for BTI";
return false;
}
exDesc.imm |= vma.addrSurface.imm << 24;
} else if (vma.addrType != AddrType::FLAT) {
uint32_t ZERO_MASK = 0xFFF;
std::string highBit = "11";
// if BTI reg or BSS/SS reg/imm with just copy
// BSS/SS with imm, value is already aligned
if (vma.addrType != AddrType::BTI && vma.addrSurface.isImm() &&
(vma.addrSurface.imm & ZERO_MASK) != 0) {
err = "BSS/SS with immediate descriptor require "
"ExDesc[" +
highBit + ":0] to be 0";
return false;
}
exDesc = vma.addrSurface;
}
//
return true;
}
bool iga::encodeDescriptorsLSC(Platform p, const VectorMessageArgs &vma,
SendDesc &exDesc, SendDesc &desc,
std::string &err) {
if (!sendOpSupportsSyntax(p, vma.op, vma.sfid)) {
err = "unsupported message for SFID";
return false;
}
return encLdStVec(p, vma,
exDesc, desc, err);
}
| [
"sys_igcbot@intel.com"
] | sys_igcbot@intel.com |
ee356d6d33ce1c7fbf743908839875fead6d58bb | ea99679b342d457b22832672e61eecb18512b25d | /src/core_io.h | 80760168d5c8531119ad1481466e4cbac5a5c979 | [
"MIT"
] | permissive | eletaNetwork/eletaNetwork | ab5cb586c8ce13380eba1eaa58327e3ecb9ec755 | c589089d189215d83a34534c82878d39b7cdda96 | refs/heads/master | 2020-03-08T19:27:51.153812 | 2018-04-13T06:01:43 | 2018-04-13T06:01:43 | 128,353,833 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,292 | h | // Copyright (c) 2009-2015 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef ELETACOIN_CORE_IO_H
#define ELETACOIN_CORE_IO_H
#include <string>
#include <vector>
class CBlock;
class CScript;
class CTransaction;
class uint256;
class UniValue;
// core_read.cpp
extern CScript ParseScript(const std::string& s);
extern std::string ScriptToAsmStr(const CScript& script, const bool fAttemptSighashDecode = false);
extern bool DecodeHexTx(CTransaction& tx, const std::string& strHexTx, bool fTryNoWitness = false);
extern bool DecodeHexBlk(CBlock&, const std::string& strHexBlk);
extern uint256 ParseHashUV(const UniValue& v, const std::string& strName);
extern uint256 ParseHashStr(const std::string&, const std::string& strName);
extern std::vector<unsigned char> ParseHexUV(const UniValue& v, const std::string& strName);
// core_write.cpp
extern std::string FormatScript(const CScript& script);
extern std::string EncodeHexTx(const CTransaction& tx);
extern void ScriptPubKeyToUniv(const CScript& scriptPubKey, UniValue& out, bool fIncludeHex);
extern void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry);
#endif // ELETACOIN_CORE_IO_H
| [
"38124337+eletaNetwork@users.noreply.github.com"
] | 38124337+eletaNetwork@users.noreply.github.com |
e5279fa87cb18b5be295e728ea2efc65804b4881 | cbe4f6d750a858f38204a9def935a25c385c6449 | /visitor11.cpp | 721852b77876ebe559e67761fb1d88189741469c | [] | no_license | dgodfrey206/Visitor11 | 909725f581b5cfc106446f96eddf8f85dee45676 | 3ff6da42b58406d728c8ad2c5b7c6c1e996cb530 | refs/heads/master | 2022-05-23T11:57:39.740553 | 2014-08-21T16:48:08 | 2014-08-21T16:48:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,711 | cpp | #include <iostream>
#include <memory>
#include <string>
// The Visitor Pattern
template<class T, class U>
std::unique_ptr<T> make_unique(U&& u)
{
return std::unique_ptr<T>(new T{std::forward<U>(u)});
}
template<class T, class... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{
return std::unique_ptr<T>(new T{std::forward<Args>(args)...});
}
class Liquor;
class Tobacco;
class Necessity;
class Visitor
{
public:
virtual ~Visitor() = default;
virtual double visit(std::unique_ptr<Liquor> liquor) = 0;
virtual double visit(std::unique_ptr<Tobacco> tobaccoItem) = 0;
virtual double visit(std::unique_ptr<Necessity> necessityItem) = 0;
};
class TaxVisitor : public Visitor
{
public:
double visit(std::unique_ptr<Liquor> liquorItem);
double visit(std::unique_ptr<Tobacco> tobaccoItem);
double visit(std::unique_ptr<Necessity> necessityItem);
};
class TaxHolidayVisitor : public Visitor
{
public:
double visit(std::unique_ptr<Liquor> liquor);
double visit(std::unique_ptr<Tobacco> tobaccoItem);
double visit(std::unique_ptr<Necessity> necessityItem);
};
class Visitable
{
virtual double accept(Visitor& visitor) = 0;
~Visitable() = default;
};
class Liquor : public Visitable
{
public:
Liquor(double item) : price(item) { }
double getPrice() { return price; }
double accept(Visitor& visitor)
{
return visitor.visit(make_unique<Liquor>(*this));
}
private:
double price;
};
class Tobacco : public Visitable
{
public:
Tobacco(double item) : price(item) { }
double getPrice() { return price; }
double accept(Visitor& visitor)
{
return visitor.visit(make_unique<Tobacco>(*this));
}
private:
double price;
};
class Necessity : public Visitable
{
public:
Necessity(double item) : price(item) { }
double getPrice() { return price; }
double accept(Visitor& visitor)
{
return visitor.visit(make_unique<Necessity>(*this));
}
private:
double price;
};
double TaxVisitor::visit(std::unique_ptr<Liquor> liquorItem)
{
std::cout << "Liquor item: Price with Tax\n";
return (liquorItem->getPrice() * .10) + liquorItem->getPrice();
}
double TaxVisitor::visit(std::unique_ptr<Tobacco> tobaccoItem)
{
std::cout << "Tobacco item: Price with Tax\n";
return (tobaccoItem->getPrice() * .32) + tobaccoItem->getPrice();
}
double TaxVisitor::visit(std::unique_ptr<Necessity> necessityItem)
{
std::cout << "Necessity item: Price with Tax\n";
return (necessityItem->getPrice() * 0) + necessityItem->getPrice();
}
double TaxHolidayVisitor::visit(std::unique_ptr<Liquor> liquorItem)
{
std::cout << "Liquor item: Price with Holiday Tax\n";
return (liquorItem->getPrice() * .5) + liquorItem->getPrice();
}
double TaxHolidayVisitor::visit(std::unique_ptr<Tobacco> tobaccoItem)
{
std::cout << "Tobacco item: Price with Holiday Tax\n";
return (tobaccoItem->getPrice() * .4) + tobaccoItem->getPrice();
}
double TaxHolidayVisitor::visit(std::unique_ptr<Necessity> necessityItem)
{
std::cout << "Necessity item: Price with Holiday Tax\n";
return (necessityItem->getPrice() * 0) + necessityItem->getPrice();
}
int main()
{
TaxVisitor tax;
TaxHolidayVisitor holiday_tax;
Liquor beer(3.50);
Tobacco cigar(10.00);
Necessity food(53.25);
std::cout << "Normal tax:\n";
std::cout << beer.accept(tax) << '\n';
std::cout << cigar.accept(tax) << '\n';
std::cout << food.accept(tax) << std::endl;
std::cout << "\nHoliday tax:\n";
std::cout << beer.accept(holiday_tax) << '\n';
std::cout << cigar.accept(holiday_tax) << '\n';
std::cout << food.accept(holiday_tax) << std::endl;
} | [
"david.godfrey99@gmail.com"
] | david.godfrey99@gmail.com |
7faf5d73cb013169cef22545571e1cb149fe990a | 417471d82b813ff2d386f8875e3f0b7836839d00 | /sources/detectors/include/ComptonG4Crystal.hh | b1bb77975ec4eaaba8d8c424a7f6d797c5b82b17 | [] | no_license | JeffersonLab/hallc_photon_comptong4 | e646a8ee7f16ca760b4c2dfc8328a1fc109fc4c8 | 88978b6532b011e7b1abf963184fde7cbe96c63a | refs/heads/master | 2020-12-29T18:51:48.850811 | 2016-06-09T19:16:01 | 2016-06-09T19:16:01 | 14,373,998 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,499 | hh | /*
* ComptonG4Crystal.hh
*
* Created on: Dec 03, 2014
* Author: Juan Carlos Cornejo <cornejo@jlab.org>
*/
#ifndef COMPTONG4CRYSTAL_HH_
#define COMPTONG4CRYSTAL_HH_
#include <VComptonG4SensitiveDetector.hh>
#include <ComptonG4EDepHit.hh>
#include <ComptonG4OpticalHit.hh>
#include <map>
#include <vector>
class ComptonG4Analysis;
class G4HCofThisEvent;
class G4Step;
class G4Track;
class G4TouchableHistory;
class ComptonG4Crystal: public VComptonG4SensitiveDetector {
public:
ComptonG4Crystal(G4String name);
virtual ~ComptonG4Crystal();
void Initialize(G4HCofThisEvent *);
G4bool ProcessHits(G4Step*, G4TouchableHistory*);
void EndOfEvent(G4HCofThisEvent*);
void CleanEvent();
/*
* Set sensitive detector options
*
* \param options The options to parse, separated by a semicolon
*/
virtual void SetOptions(std::map<G4String,G4String> options,
bool ignore_unknown);
/*
* Create and initialize the Output Branch
*/
virtual void CreateTreeBranch(TTree *branch);
/*
* Add a managed volume to this SD
*/
virtual void AddVolume(G4VPhysicalVolume* vol) {
VComptonG4SensitiveDetector::AddVolume(vol);
std::vector<ComptonG4EDepHit> hit_edep;
fEDepHits.push_back(hit_edep);
std::vector<ComptonG4OpticalHit> hit_optical;
fOpticalHits.push_back(hit_optical);
std::vector<ComptonG4EDepData> data_edep;
fEDepData.push_back(data_edep);
fEDepDataPtr.push_back(&fEDepData.back());
std::vector<ComptonG4OpticalData> data_optical;
fOpticalData.push_back(data_optical);
fOpticalDataPtr.push_back(&fOpticalData.back());
fTotalEnergyDeposited.push_back(0.0);
fTotalOpticalPhotons.push_back(0);
}
virtual void CheckUniqueTrack(G4Track *track);
private:
std::vector<std::vector<ComptonG4EDepHit> > fEDepHits;
std::vector<std::vector<ComptonG4OpticalHit> > fOpticalHits;
std::vector<std::vector<ComptonG4EDepData> > fEDepData;
std::vector<std::vector<ComptonG4OpticalData> > fOpticalData;
std::vector<std::vector<ComptonG4EDepData>* > fEDepDataPtr;
std::vector<std::vector<ComptonG4OpticalData>* > fOpticalDataPtr;
std::vector<G4double> fTotalEnergyDeposited;
std::vector<G4int> fTotalOpticalPhotons;
G4int fTotalOpticalCerenkov;
G4int fTotalOpticalScintillation;
G4int fTotalOpticalOther;
std::vector<G4int> fOpticalProducedTrackID;
std::vector<G4int> fOpticalProducedProcess;
bool fStoreEDepHits;
bool fStoreOpticalHits;
};
#endif /* COMPTONG4CRYSTAL_HH_ */
| [
"cornejo@jlab.org"
] | cornejo@jlab.org |
29a64ff9e225c7b8730af0703576ba2ee80759ef | f22ebc1404ee597fecbb08ecba4bc01f7fbb0150 | /ch07/exercise7.40.cpp | 29e3a04f10e1651dbf2f328093d17318ef891afe | [] | no_license | matriiix67/cpp-primer | ccb3bd12771488090121d0f336cbb4bfd825f058 | ee10f444ecfb66c5dcf9b88a6af3766f98f152ed | refs/heads/master | 2021-01-21T04:44:31.816805 | 2018-04-02T10:15:00 | 2018-04-02T10:15:00 | 45,467,049 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 467 | cpp | #include <iostream>
#include <string>
class Book
{
public:
Book(unsigned isbn, std::string const& name, std::string const& author, std::string const& pubdate)
:isbn_(isbn), name_(name), author_(author), pubdate_(pubdate)
{ }
explicit Book(std::istream &in)
{
in >> isbn_ >> name_ >> author_ >> pubdate_;
}
private:
unsigned isbn_;
std::string name_;
std::string author_;
std::string pubdate_;
};
| [
"matriiix67@gmail.com"
] | matriiix67@gmail.com |
cd94c78a97eb6501eb653491f23c04aedfb40e54 | 29f2549998b45a046930f3b1c5e3024791b1be16 | /lib/Transforms/Instrumentation/RSProfiling.cpp | 9997d9dca98bf041acf76493dc4cd4eee37ebc3f | [
"NCSA"
] | permissive | fanfuqiang/iec-61131_new | eda210bd30a6a32e3d14c3d3e87f51b179124c72 | fde56fdefd60e33facaa07661e388ed6c916c763 | refs/heads/master | 2016-09-05T14:59:12.678870 | 2015-02-06T23:55:09 | 2015-02-06T23:55:09 | 30,048,552 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 23,836 | cpp | //===- RSProfiling.cpp - Various profiling using random sampling ----------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// These passes implement a random sampling based profiling. Different methods
// of choosing when to sample are supported, as well as different types of
// profiling. This is done as two passes. The first is a sequence of profiling
// passes which insert profiling into the program, and remember what they
// inserted.
//
// The second stage duplicates all instructions in a function, ignoring the
// profiling code, then connects the two versions togeather at the entry and at
// backedges. At each connection point a choice is made as to whether to jump
// to the profiled code (take a sample) or execute the unprofiled code.
//
// It is highly recommended that after this pass one runs mem2reg and adce
// (instcombine load-vn gdce dse also are good to run afterwards)
//
// This design is intended to make the profiling passes independent of the RS
// framework, but any profiling pass that implements the RSProfiling interface
// is compatible with the rs framework (and thus can be sampled)
//
// TODO: obviously the block and function profiling are almost identical to the
// existing ones, so they can be unified (esp since these passes are valid
// without the rs framework).
// TODO: Fix choice code so that frequency is not hard coded
//
//===----------------------------------------------------------------------===//
#include "llvm/Pass.h"
#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/Instructions.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Intrinsics.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Instrumentation.h"
#include "RSProfiling.h"
#include <set>
#include <map>
#include <queue>
using namespace llvm;
namespace {
enum RandomMeth {
GBV, GBVO, HOSTCC
};
}
static cl::opt<RandomMeth> RandomMethod("profile-randomness",
cl::desc("How to randomly choose to profile:"),
cl::values(
clEnumValN(GBV, "global", "global counter"),
clEnumValN(GBVO, "ra_global",
"register allocated global counter"),
clEnumValN(HOSTCC, "rdcc", "cycle counter"),
clEnumValEnd));
namespace {
/// NullProfilerRS - The basic profiler that does nothing. It is the default
/// profiler and thus terminates RSProfiler chains. It is useful for
/// measuring framework overhead
class VISIBILITY_HIDDEN NullProfilerRS : public RSProfilers {
public:
static char ID; // Pass identification, replacement for typeid
bool isProfiling(Value* v) {
return false;
}
bool runOnModule(Module &M) {
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
}
};
}
static RegisterAnalysisGroup<RSProfilers> A("Profiling passes");
static RegisterPass<NullProfilerRS> NP("insert-null-profiling-rs",
"Measure profiling framework overhead");
static RegisterAnalysisGroup<RSProfilers, true> NPT(NP);
namespace {
/// Chooser - Something that chooses when to make a sample of the profiled code
class VISIBILITY_HIDDEN Chooser {
public:
/// ProcessChoicePoint - is called for each basic block inserted to choose
/// between normal and sample code
virtual void ProcessChoicePoint(BasicBlock*) = 0;
/// PrepFunction - is called once per function before other work is done.
/// This gives the opertunity to insert new allocas and such.
virtual void PrepFunction(Function*) = 0;
virtual ~Chooser() {}
};
//Things that implement sampling policies
//A global value that is read-mod-stored to choose when to sample.
//A sample is taken when the global counter hits 0
class VISIBILITY_HIDDEN GlobalRandomCounter : public Chooser {
GlobalVariable* Counter;
Value* ResetValue;
const IntegerType* T;
public:
GlobalRandomCounter(Module& M, const IntegerType* t, uint64_t resetval);
virtual ~GlobalRandomCounter();
virtual void PrepFunction(Function* F);
virtual void ProcessChoicePoint(BasicBlock* bb);
};
//Same is GRC, but allow register allocation of the global counter
class VISIBILITY_HIDDEN GlobalRandomCounterOpt : public Chooser {
GlobalVariable* Counter;
Value* ResetValue;
AllocaInst* AI;
const IntegerType* T;
public:
GlobalRandomCounterOpt(Module& M, const IntegerType* t, uint64_t resetval);
virtual ~GlobalRandomCounterOpt();
virtual void PrepFunction(Function* F);
virtual void ProcessChoicePoint(BasicBlock* bb);
};
//Use the cycle counter intrinsic as a source of pseudo randomness when
//deciding when to sample.
class VISIBILITY_HIDDEN CycleCounter : public Chooser {
uint64_t rm;
Constant *F;
public:
CycleCounter(Module& m, uint64_t resetmask);
virtual ~CycleCounter();
virtual void PrepFunction(Function* F);
virtual void ProcessChoicePoint(BasicBlock* bb);
};
/// ProfilerRS - Insert the random sampling framework
struct VISIBILITY_HIDDEN ProfilerRS : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
ProfilerRS() : FunctionPass(&ID) {}
std::map<Value*, Value*> TransCache;
std::set<BasicBlock*> ChoicePoints;
Chooser* c;
//Translate and duplicate values for the new profile free version of stuff
Value* Translate(Value* v);
//Duplicate an entire function (with out profiling)
void Duplicate(Function& F, RSProfilers& LI);
//Called once for each backedge, handle the insertion of choice points and
//the interconection of the two versions of the code
void ProcessBackEdge(BasicBlock* src, BasicBlock* dst, Function& F);
bool runOnFunction(Function& F);
bool doInitialization(Module &M);
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
};
}
static RegisterPass<ProfilerRS>
X("insert-rs-profiling-framework",
"Insert random sampling instrumentation framework");
char RSProfilers::ID = 0;
char NullProfilerRS::ID = 0;
char ProfilerRS::ID = 0;
//Local utilities
static void ReplacePhiPred(BasicBlock* btarget,
BasicBlock* bold, BasicBlock* bnew);
static void CollapsePhi(BasicBlock* btarget, BasicBlock* bsrc);
template<class T>
static void recBackEdge(BasicBlock* bb, T& BackEdges,
std::map<BasicBlock*, int>& color,
std::map<BasicBlock*, int>& depth,
std::map<BasicBlock*, int>& finish,
int& time);
//find the back edges and where they go to
template<class T>
static void getBackEdges(Function& F, T& BackEdges);
///////////////////////////////////////
// Methods of choosing when to profile
///////////////////////////////////////
GlobalRandomCounter::GlobalRandomCounter(Module& M, const IntegerType* t,
uint64_t resetval) : T(t) {
ConstantInt* Init = ConstantInt::get(T, resetval);
ResetValue = Init;
Counter = new GlobalVariable(M, T, false, GlobalValue::InternalLinkage,
Init, "RandomSteeringCounter");
}
GlobalRandomCounter::~GlobalRandomCounter() {}
void GlobalRandomCounter::PrepFunction(Function* F) {}
void GlobalRandomCounter::ProcessChoicePoint(BasicBlock* bb) {
BranchInst* t = cast<BranchInst>(bb->getTerminator());
//decrement counter
LoadInst* l = new LoadInst(Counter, "counter", t);
ICmpInst* s = new ICmpInst(t, ICmpInst::ICMP_EQ, l,
ConstantInt::get(T, 0),
"countercc");
Value* nv = BinaryOperator::CreateSub(l, ConstantInt::get(T, 1),
"counternew", t);
new StoreInst(nv, Counter, t);
t->setCondition(s);
//reset counter
BasicBlock* oldnext = t->getSuccessor(0);
BasicBlock* resetblock = BasicBlock::Create(bb->getContext(),
"reset", oldnext->getParent(),
oldnext);
TerminatorInst* t2 = BranchInst::Create(oldnext, resetblock);
t->setSuccessor(0, resetblock);
new StoreInst(ResetValue, Counter, t2);
ReplacePhiPred(oldnext, bb, resetblock);
}
GlobalRandomCounterOpt::GlobalRandomCounterOpt(Module& M, const IntegerType* t,
uint64_t resetval)
: AI(0), T(t) {
ConstantInt* Init = ConstantInt::get(T, resetval);
ResetValue = Init;
Counter = new GlobalVariable(M, T, false, GlobalValue::InternalLinkage,
Init, "RandomSteeringCounter");
}
GlobalRandomCounterOpt::~GlobalRandomCounterOpt() {}
void GlobalRandomCounterOpt::PrepFunction(Function* F) {
//make a local temporary to cache the global
BasicBlock& bb = F->getEntryBlock();
BasicBlock::iterator InsertPt = bb.begin();
AI = new AllocaInst(T, 0, "localcounter", InsertPt);
LoadInst* l = new LoadInst(Counter, "counterload", InsertPt);
new StoreInst(l, AI, InsertPt);
//modify all functions and return values to restore the local variable to/from
//the global variable
for(Function::iterator fib = F->begin(), fie = F->end();
fib != fie; ++fib)
for(BasicBlock::iterator bib = fib->begin(), bie = fib->end();
bib != bie; ++bib)
if (isa<CallInst>(bib)) {
LoadInst* l = new LoadInst(AI, "counter", bib);
new StoreInst(l, Counter, bib);
l = new LoadInst(Counter, "counter", ++bib);
new StoreInst(l, AI, bib--);
} else if (isa<InvokeInst>(bib)) {
LoadInst* l = new LoadInst(AI, "counter", bib);
new StoreInst(l, Counter, bib);
BasicBlock* bb = cast<InvokeInst>(bib)->getNormalDest();
BasicBlock::iterator i = bb->getFirstNonPHI();
l = new LoadInst(Counter, "counter", i);
bb = cast<InvokeInst>(bib)->getUnwindDest();
i = bb->getFirstNonPHI();
l = new LoadInst(Counter, "counter", i);
new StoreInst(l, AI, i);
} else if (isa<UnwindInst>(&*bib) || isa<ReturnInst>(&*bib)) {
LoadInst* l = new LoadInst(AI, "counter", bib);
new StoreInst(l, Counter, bib);
}
}
void GlobalRandomCounterOpt::ProcessChoicePoint(BasicBlock* bb) {
BranchInst* t = cast<BranchInst>(bb->getTerminator());
//decrement counter
LoadInst* l = new LoadInst(AI, "counter", t);
ICmpInst* s = new ICmpInst(t, ICmpInst::ICMP_EQ, l,
ConstantInt::get(T, 0),
"countercc");
Value* nv = BinaryOperator::CreateSub(l, ConstantInt::get(T, 1),
"counternew", t);
new StoreInst(nv, AI, t);
t->setCondition(s);
//reset counter
BasicBlock* oldnext = t->getSuccessor(0);
BasicBlock* resetblock = BasicBlock::Create(bb->getContext(),
"reset", oldnext->getParent(),
oldnext);
TerminatorInst* t2 = BranchInst::Create(oldnext, resetblock);
t->setSuccessor(0, resetblock);
new StoreInst(ResetValue, AI, t2);
ReplacePhiPred(oldnext, bb, resetblock);
}
CycleCounter::CycleCounter(Module& m, uint64_t resetmask) : rm(resetmask) {
F = Intrinsic::getDeclaration(&m, Intrinsic::readcyclecounter);
}
CycleCounter::~CycleCounter() {}
void CycleCounter::PrepFunction(Function* F) {}
void CycleCounter::ProcessChoicePoint(BasicBlock* bb) {
BranchInst* t = cast<BranchInst>(bb->getTerminator());
CallInst* c = CallInst::Create(F, "rdcc", t);
BinaryOperator* b =
BinaryOperator::CreateAnd(c,
ConstantInt::get(Type::getInt64Ty(bb->getContext()), rm),
"mrdcc", t);
ICmpInst *s = new ICmpInst(t, ICmpInst::ICMP_EQ, b,
ConstantInt::get(Type::getInt64Ty(bb->getContext()), 0),
"mrdccc");
t->setCondition(s);
}
///////////////////////////////////////
// Profiling:
///////////////////////////////////////
bool RSProfilers_std::isProfiling(Value* v) {
if (profcode.find(v) != profcode.end())
return true;
//else
RSProfilers& LI = getAnalysis<RSProfilers>();
return LI.isProfiling(v);
}
void RSProfilers_std::IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum,
GlobalValue *CounterArray) {
// Insert the increment after any alloca or PHI instructions...
BasicBlock::iterator InsertPos = BB->getFirstNonPHI();
while (isa<AllocaInst>(InsertPos))
++InsertPos;
// Create the getelementptr constant expression
std::vector<Constant*> Indices(2);
Indices[0] = Constant::getNullValue(Type::getInt32Ty(BB->getContext()));
Indices[1] = ConstantInt::get(Type::getInt32Ty(BB->getContext()), CounterNum);
Constant *ElementPtr =ConstantExpr::getGetElementPtr(CounterArray,
&Indices[0], 2);
// Load, increment and store the value back.
Value *OldVal = new LoadInst(ElementPtr, "OldCounter", InsertPos);
profcode.insert(OldVal);
Value *NewVal = BinaryOperator::CreateAdd(OldVal,
ConstantInt::get(Type::getInt32Ty(BB->getContext()), 1),
"NewCounter", InsertPos);
profcode.insert(NewVal);
profcode.insert(new StoreInst(NewVal, ElementPtr, InsertPos));
}
void RSProfilers_std::getAnalysisUsage(AnalysisUsage &AU) const {
//grab any outstanding profiler, or get the null one
AU.addRequired<RSProfilers>();
}
///////////////////////////////////////
// RS Framework
///////////////////////////////////////
Value* ProfilerRS::Translate(Value* v) {
if(TransCache[v])
return TransCache[v];
if (BasicBlock* bb = dyn_cast<BasicBlock>(v)) {
if (bb == &bb->getParent()->getEntryBlock())
TransCache[bb] = bb; //don't translate entry block
else
TransCache[bb] = BasicBlock::Create(v->getContext(),
"dup_" + bb->getName(),
bb->getParent(), NULL);
return TransCache[bb];
} else if (Instruction* i = dyn_cast<Instruction>(v)) {
//we have already translated this
//do not translate entry block allocas
if(&i->getParent()->getParent()->getEntryBlock() == i->getParent()) {
TransCache[i] = i;
return i;
} else {
//translate this
Instruction* i2 = i->clone(v->getContext());
if (i->hasName())
i2->setName("dup_" + i->getName());
TransCache[i] = i2;
//NumNewInst++;
for (unsigned x = 0; x < i2->getNumOperands(); ++x)
i2->setOperand(x, Translate(i2->getOperand(x)));
return i2;
}
} else if (isa<Function>(v) || isa<Constant>(v) || isa<Argument>(v)) {
TransCache[v] = v;
return v;
}
llvm_unreachable("Value not handled");
return 0;
}
void ProfilerRS::Duplicate(Function& F, RSProfilers& LI)
{
//perform a breadth first search, building up a duplicate of the code
std::queue<BasicBlock*> worklist;
std::set<BasicBlock*> seen;
//This loop ensures proper BB order, to help performance
for (Function::iterator fib = F.begin(), fie = F.end(); fib != fie; ++fib)
worklist.push(fib);
while (!worklist.empty()) {
Translate(worklist.front());
worklist.pop();
}
//remember than reg2mem created a new entry block we don't want to duplicate
worklist.push(F.getEntryBlock().getTerminator()->getSuccessor(0));
seen.insert(&F.getEntryBlock());
while (!worklist.empty()) {
BasicBlock* bb = worklist.front();
worklist.pop();
if(seen.find(bb) == seen.end()) {
BasicBlock* bbtarget = cast<BasicBlock>(Translate(bb));
BasicBlock::InstListType& instlist = bbtarget->getInstList();
for (BasicBlock::iterator iib = bb->begin(), iie = bb->end();
iib != iie; ++iib) {
//NumOldInst++;
if (!LI.isProfiling(&*iib)) {
Instruction* i = cast<Instruction>(Translate(iib));
instlist.insert(bbtarget->end(), i);
}
}
//updated search state;
seen.insert(bb);
TerminatorInst* ti = bb->getTerminator();
for (unsigned x = 0; x < ti->getNumSuccessors(); ++x) {
BasicBlock* bbs = ti->getSuccessor(x);
if (seen.find(bbs) == seen.end()) {
worklist.push(bbs);
}
}
}
}
}
void ProfilerRS::ProcessBackEdge(BasicBlock* src, BasicBlock* dst, Function& F) {
//given a backedge from B -> A, and translations A' and B',
//a: insert C and C'
//b: add branches in C to A and A' and in C' to A and A'
//c: mod terminators@B, replace A with C
//d: mod terminators@B', replace A' with C'
//e: mod phis@A for pred B to be pred C
// if multiple entries, simplify to one
//f: mod phis@A' for pred B' to be pred C'
// if multiple entries, simplify to one
//g: for all phis@A with pred C using x
// add in edge from C' using x'
// add in edge from C using x in A'
//a:
Function::iterator BBN = src; ++BBN;
BasicBlock* bbC = BasicBlock::Create(F.getContext(), "choice", &F, BBN);
//ChoicePoints.insert(bbC);
BBN = cast<BasicBlock>(Translate(src));
BasicBlock* bbCp = BasicBlock::Create(F.getContext(), "choice", &F, ++BBN);
ChoicePoints.insert(bbCp);
//b:
BranchInst::Create(cast<BasicBlock>(Translate(dst)), bbC);
BranchInst::Create(dst, cast<BasicBlock>(Translate(dst)),
ConstantInt::get(Type::getInt1Ty(src->getContext()), true), bbCp);
//c:
{
TerminatorInst* iB = src->getTerminator();
for (unsigned x = 0; x < iB->getNumSuccessors(); ++x)
if (iB->getSuccessor(x) == dst)
iB->setSuccessor(x, bbC);
}
//d:
{
TerminatorInst* iBp = cast<TerminatorInst>(Translate(src->getTerminator()));
for (unsigned x = 0; x < iBp->getNumSuccessors(); ++x)
if (iBp->getSuccessor(x) == cast<BasicBlock>(Translate(dst)))
iBp->setSuccessor(x, bbCp);
}
//e:
ReplacePhiPred(dst, src, bbC);
//src could be a switch, in which case we are replacing several edges with one
//thus collapse those edges int the Phi
CollapsePhi(dst, bbC);
//f:
ReplacePhiPred(cast<BasicBlock>(Translate(dst)),
cast<BasicBlock>(Translate(src)),bbCp);
CollapsePhi(cast<BasicBlock>(Translate(dst)), bbCp);
//g:
for(BasicBlock::iterator ib = dst->begin(), ie = dst->end(); ib != ie;
++ib)
if (PHINode* phi = dyn_cast<PHINode>(&*ib)) {
for(unsigned x = 0; x < phi->getNumIncomingValues(); ++x)
if(bbC == phi->getIncomingBlock(x)) {
phi->addIncoming(Translate(phi->getIncomingValue(x)), bbCp);
cast<PHINode>(Translate(phi))->addIncoming(phi->getIncomingValue(x),
bbC);
}
phi->removeIncomingValue(bbC);
}
}
bool ProfilerRS::runOnFunction(Function& F) {
if (!F.isDeclaration()) {
std::set<std::pair<BasicBlock*, BasicBlock*> > BackEdges;
RSProfilers& LI = getAnalysis<RSProfilers>();
getBackEdges(F, BackEdges);
Duplicate(F, LI);
//assume that stuff worked. now connect the duplicated basic blocks
//with the originals in such a way as to preserve ssa. yuk!
for (std::set<std::pair<BasicBlock*, BasicBlock*> >::iterator
ib = BackEdges.begin(), ie = BackEdges.end(); ib != ie; ++ib)
ProcessBackEdge(ib->first, ib->second, F);
//oh, and add the edge from the reg2mem created entry node to the
//duplicated second node
TerminatorInst* T = F.getEntryBlock().getTerminator();
ReplaceInstWithInst(T, BranchInst::Create(T->getSuccessor(0),
cast<BasicBlock>(
Translate(T->getSuccessor(0))),
ConstantInt::get(Type::getInt1Ty(F.getContext()), true)));
//do whatever is needed now that the function is duplicated
c->PrepFunction(&F);
//add entry node to choice points
ChoicePoints.insert(&F.getEntryBlock());
for (std::set<BasicBlock*>::iterator
ii = ChoicePoints.begin(), ie = ChoicePoints.end(); ii != ie; ++ii)
c->ProcessChoicePoint(*ii);
ChoicePoints.clear();
TransCache.clear();
return true;
}
return false;
}
bool ProfilerRS::doInitialization(Module &M) {
switch (RandomMethod) {
case GBV:
c = new GlobalRandomCounter(M, Type::getInt32Ty(M.getContext()),
(1 << 14) - 1);
break;
case GBVO:
c = new GlobalRandomCounterOpt(M, Type::getInt32Ty(M.getContext()),
(1 << 14) - 1);
break;
case HOSTCC:
c = new CycleCounter(M, (1 << 14) - 1);
break;
};
return true;
}
void ProfilerRS::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<RSProfilers>();
AU.addRequiredID(DemoteRegisterToMemoryID);
}
///////////////////////////////////////
// Utilities:
///////////////////////////////////////
static void ReplacePhiPred(BasicBlock* btarget,
BasicBlock* bold, BasicBlock* bnew) {
for(BasicBlock::iterator ib = btarget->begin(), ie = btarget->end();
ib != ie; ++ib)
if (PHINode* phi = dyn_cast<PHINode>(&*ib)) {
for(unsigned x = 0; x < phi->getNumIncomingValues(); ++x)
if(bold == phi->getIncomingBlock(x))
phi->setIncomingBlock(x, bnew);
}
}
static void CollapsePhi(BasicBlock* btarget, BasicBlock* bsrc) {
for(BasicBlock::iterator ib = btarget->begin(), ie = btarget->end();
ib != ie; ++ib)
if (PHINode* phi = dyn_cast<PHINode>(&*ib)) {
std::map<BasicBlock*, Value*> counter;
for(unsigned i = 0; i < phi->getNumIncomingValues(); ) {
if (counter[phi->getIncomingBlock(i)]) {
assert(phi->getIncomingValue(i) == counter[phi->getIncomingBlock(i)]);
phi->removeIncomingValue(i, false);
} else {
counter[phi->getIncomingBlock(i)] = phi->getIncomingValue(i);
++i;
}
}
}
}
template<class T>
static void recBackEdge(BasicBlock* bb, T& BackEdges,
std::map<BasicBlock*, int>& color,
std::map<BasicBlock*, int>& depth,
std::map<BasicBlock*, int>& finish,
int& time)
{
color[bb] = 1;
++time;
depth[bb] = time;
TerminatorInst* t= bb->getTerminator();
for(unsigned i = 0; i < t->getNumSuccessors(); ++i) {
BasicBlock* bbnew = t->getSuccessor(i);
if (color[bbnew] == 0)
recBackEdge(bbnew, BackEdges, color, depth, finish, time);
else if (color[bbnew] == 1) {
BackEdges.insert(std::make_pair(bb, bbnew));
//NumBackEdges++;
}
}
color[bb] = 2;
++time;
finish[bb] = time;
}
//find the back edges and where they go to
template<class T>
static void getBackEdges(Function& F, T& BackEdges) {
std::map<BasicBlock*, int> color;
std::map<BasicBlock*, int> depth;
std::map<BasicBlock*, int> finish;
int time = 0;
recBackEdge(&F.getEntryBlock(), BackEdges, color, depth, finish, time);
DEBUG(errs() << F.getName() << " " << BackEdges.size() << "\n");
}
//Creation functions
ModulePass* llvm::createNullProfilerRSPass() {
return new NullProfilerRS();
}
FunctionPass* llvm::createRSProfilingPass() {
return new ProfilerRS();
}
| [
"feqin1023@gmail.com"
] | feqin1023@gmail.com |
3b920cc619f615d465e83978ee9065a72dcb3c20 | 8c540a482bdf6217c3f72aebf8a13966a6b48dbe | /containers/matrix.cpp | 1b0fb3edb2fb6466234c905824f8aa486c63263c | [] | no_license | eyupgurel/workbench | 6633d131fac470ed981bcd193684b28948af1af6 | 4af3e71444f96a8ccff6bf594867daca48f2119e | refs/heads/master | 2020-04-21T16:17:29.864851 | 2019-10-16T19:45:30 | 2019-10-16T19:45:30 | 169,695,934 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,363 | cpp | //
// Created by egl on 6/17/19.
//
#include <numeric>
#include "matrix.h"
using namespace containers;
template<typename T,size_t N>
Matrix<T,N> containers::operator+(const Matrix<T,N>& m,const T& val){
Matrix<T,N> res=m;
res+=val;
return res;
}
template<typename T,size_t N>
Matrix<T,N> containers::operator-(const Matrix<T,N>& m,const T& val){
Matrix<T,N> res=m;
res-=val;
return res;
}
template<typename T,size_t N>
Matrix<T,N> containers::operator*(const Matrix<T,N>& m,const T& val){
Matrix<T,N> res=m;
res*=val;
return res;
}
template<typename T,size_t N>
Matrix<T,N> containers::operator/(const Matrix<T,N>& m,const T& val){
Matrix<T,N> res=m;
res+=val;
return res;
}
template<typename T,size_t N>
Matrix<T,N> containers::operator%(const Matrix<T,N>& m,const T& val){
Matrix<T,N> res=m;
res%=val;
return res;
}
template<typename T, size_t N>
Matrix<T,N> containers::operator+(const Matrix<T,N>& a, const Matrix<T,N>& b){
Matrix<T,N> res = a;
res+=b;
return res;
}
template<typename T, size_t N>
Matrix<T,N> containers::operator-(const Matrix<T,N>& a, const Matrix<T,N>& b){
Matrix<T,N> res = a;
res-=b;
return res;
}
template<typename T>
Matrix<T,2> containers::operator*(const Matrix<T,1>&u, const Matrix<T,1>&v){
const size_t n = u.extent();
const size_t m = v.extent();
Matrix<T,2> res(n,m);
for(size_t i=0; i<n; ++i)
for(size_t j=0; j<m;++j)
res(i,j)=u[i]*v[j];
return res;
}
template<typename T>
Matrix<T,1> containers::operator*(const Matrix<T,2>&u, const Matrix<T,1>&v){
assert(u.extent(1)==v.extent(0));
const size_t n=u.extent(0);
const size_t m=u.extent(1);
Matrix<T,1> res(n);
for(size_t i=0; i<n; ++i)
for(size_t j=0; j<m; ++j)
res(i)+=u[j]*v[j];
return res;
}
template<typename T>
Matrix<T,2> containers::operator*(const Matrix<T,2>&u, const Matrix<T,2>&v){
assert(u.extent(1)==v.extent(0));
size_t m=u.extent(0);
size_t n=v.extent(1);
size_t p=u.extent(1);
Matrix<T,2>res(m,n);
for(size_t i=0; i<m;++i)
for(size_t j=0; j<n; ++j)
for(size_t k=0; k<p; ++k)
res(i,j)+=u(i,k)*v(k,j);
return res;
}
void drive_matrix(){
Matrix<int,2> m2 {
{1,2,3},
{11,12,13}
};
}
| [
"eyupgurel@gmail.com"
] | eyupgurel@gmail.com |
b19607066a6bbe8b22f4804ed3319dbac9e4272a | 5ed2ca9c903d78dec4f2abff005d39ed5f8c34b7 | /105. Construct Binary Tree from Preorder and Inorder Traversal/src/main.cpp | de29c8b6e31cc7e269f35d06cfbc721adf267d20 | [
"MIT"
] | permissive | zhenkunhe/LeetCode | 68faad793c06bc33a7ddf6431bf2fb6d400ea8ac | 17a9a4d63d21888c7e7d300d5e29201f8621fd63 | refs/heads/master | 2021-10-22T00:40:39.357907 | 2019-03-07T11:01:28 | 2019-03-07T11:01:28 | 111,090,427 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,747 | cpp | #include <iostream>
#include <algorithm>
#include <vector>
#include <unordered_map>
#include <tree.hpp>
using namespace std;
class Solution
{
public:
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder)
{
if ( preorder.size() == 0 ) return nullptr;
TreeNode *root = new TreeNode(preorder.front());
int index = distance(inorder.begin(), find(inorder.begin(), inorder.end(), preorder.front()));
vector<int>::iterator i = inorder.begin();
vector<int>::iterator p = preorder.begin();
vector<int> inorder_left(i, i + index);
vector<int> inorder_right(i + index + 1, inorder.end());
vector<int> preorder_left(p+1, p + 1+index);
vector<int> preorder_right(p + 1 + index, preorder.end());
root->left = buildTree(preorder_left, inorder_left);
root->right = buildTree(preorder_right, inorder_right);
return root;
}
};
class Solution2
{
public:
TreeNode *buildTree(vector<int>& preorder, vector<int>& inorder)
{
int size = inorder.size() - 1;
for (int i = 0; i <= size; ++i)
index[inorder[i]] = i;
cur = 0;
return buildTree(preorder, inorder, 0, size);
}
TreeNode *buildTree(vector<int>& preorder, vector<int>& inorder, int start, int end)
{
if ( end < start ) return nullptr;
int val = preorder[cur++], loc = index[val]; // Move cur 1 higher (must be left of root, since preorder)
TreeNode *head = new TreeNode(val);
head->left = buildTree(preorder, inorder, start, loc - 1);
head->right = buildTree(preorder, inorder, loc + 1, end);
return head;
}
private:
int cur;
unordered_map<int, int> index;
};
int main()
{
Solution2 s;
vector<int> preorder { 3, 9, 20, 15, 7 };
vector<int> inorder { 9, 3, 15, 20, 7 };
prettyPrintTree(s.buildTree(preorder, inorder));
return 0;
}
| [
"zhenkunhe@gmail.com"
] | zhenkunhe@gmail.com |
936eb5e13c5724ce3d1a75227cec22f2ba2b34d0 | 6adaf5286b0d72fa4f0df4aa9abddccc4cdfd1c1 | /customtower/nklib/src/memory.cpp | bdefbc6c0e4b0f799b21dd9aa53de00553a4f879 | [
"MIT"
] | permissive | myumoon/customtower | 34b00212b7b3308b0b86b90ae04e94a7b87ac1af | 85980f5aea1f8b869069ed1da3a14491e2dc8968 | refs/heads/master | 2021-01-25T05:09:58.140180 | 2017-06-06T13:02:43 | 2017-06-06T13:02:43 | 93,515,235 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 748 | cpp | //=============================================================================
/*! @file memory.cpp
@brief メモリ操作
@author ryunosuke ide
@date 2013.05.06
*/
//=============================================================================
//-------------------------------インクルード-------------------------------
#include "../../include/system"
//--------------------------------define定義--------------------------------
//--------------------------------static変数--------------------------------
namespace {
} // unnamed
//--------------------------------static関数--------------------------------
namespace {
} // unnamed
//---------------------------------関数定義---------------------------------
| [
"ryumyu0120@gmail.com"
] | ryumyu0120@gmail.com |
4885a18348902308f01b7f1685617ab1fc842519 | b7881f178c7ecf030e1b540885181a617124b79a | /WildFireInstance/WildFireInstance.ino | 86524b46cf37b6771820fa817a96b41d928c2817 | [] | no_license | jrleeman/WeeStinkyMonitor | 7303137593d03d1edb46e46b7b8a0c7a64540f0f | 163c35c733fb1d93ffcd0b58dfa315b0f275762b | refs/heads/master | 2021-01-14T08:47:05.590178 | 2015-07-28T19:27:03 | 2015-07-28T19:27:03 | 39,889,353 | 0 | 0 | null | 2015-07-29T11:12:52 | 2015-07-29T11:12:49 | Arduino | UTF-8 | C++ | false | false | 7,336 | ino | /***************************************************
This is an example for the Adafruit CC3000 Wifi Breakout & Shield
Designed specifically to work with the Adafruit WiFi products:
----> https://www.adafruit.com/products/1469
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
Written by Limor Fried & Kevin Townsend for Adafruit Industries.
BSD license, all text above must be included in any redistribution
****************************************************/
/*
This example does a test of the TCP client capability:
* Initialization
* Optional: SSID scan
* AP connection
* DHCP printout
* DNS lookup
* Optional: Ping
* Connect to website and print out webpage contents
* Disconnect
SmartConfig is still beta and kind of works but is not fully vetted!
It might not work on all networks!
*/
#include <WildFire_CC3000.h>
#include <ccspi.h>
#include <SPI.h>
#include <string.h>
#include "utility/debug.h"
#include <WildFire.h>
WildFire wildfire;
WildFire_CC3000 cc3000;
#define WLAN_SSID "RedRover" // cannot be longer than 32 characters!
#define WLAN_PASS "myPassword"
// Security can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, WLAN_SEC_WPA or WLAN_SEC_WPA2
#define WLAN_SECURITY WLAN_SEC_UNSEC
#define IDLE_TIMEOUT_MS 3000 // Amount of time to wait (in milliseconds) with no data
// received before closing the connection. If you know the server
// you're accessing is quick to respond, you can reduce this value.
// What page to grab!
#define WEBSITE "data.sparkfun.com"
#define WEBPAGE "input/MGGvD5py95U3KE3q8Qlq?private_key=nzzox2krM2hVldVqDXZq&"
/**************************************************************************/
/*!
@brief Sets up the HW and the CC3000 module (called automatically
on startup)
*/
/**************************************************************************/
uint32_t ip;
void setup(void)
{
wildfire.begin();
Serial.begin(115200);
Serial.println(F("Hello, CC3000!\n"));
Serial.print("Free RAM: "); Serial.println(getFreeRam(), DEC);
/* Initialise the module */
Serial.println(F("\nInitializing..."));
if (!cc3000.begin())
{
Serial.println(F("Couldn't begin()! Check your wiring?"));
while(1);
}
// Optional SSID scan
// listSSIDResults();
Serial.print(F("\nAttempting to connect to ")); Serial.println(WLAN_SSID);
if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) {
Serial.println(F("Failed!"));
while(1);
}
Serial.println(F("Connected!"));
/* Wait for DHCP to complete */
Serial.println(F("Request DHCP"));
while (!cc3000.checkDHCP())
{
delay(100); // ToDo: Insert a DHCP timeout!
}
/* Display the IP address DNS, Gateway, etc. */
while (! displayConnectionDetails()) {
delay(1000);
}
ip = 0;
// Try looking up the website's IP address
Serial.print(WEBSITE); Serial.print(F(" -> "));
while (ip == 0) {
if (! cc3000.getHostByName(WEBSITE, &ip)) {
Serial.println(F("Couldn't resolve!"));
}
delay(500);
}
cc3000.printIPdotsRev(ip);
// Optional: Do a ping test on the website
/*
Serial.print(F("\n\rPinging ")); cc3000.printIPdotsRev(ip); Serial.print("...");
replies = cc3000.ping(ip, 5);
Serial.print(replies); Serial.println(F(" replies"));
*/
/* Try connecting to the website.
Note: HTTP/1.1 protocol is used to keep the server from closing the connection before all data is read.
*/
WildFire_CC3000_Client www = cc3000.connectTCP(ip, 80);
if (www.connected()) {
www.fastrprint(F("GET "));
www.fastrprint(WEBPAGE);
www.fastrprint(F(" HTTP/1.1\r\n"));
www.fastrprint(F("Host: ")); www.fastrprint(WEBSITE); www.fastrprint(F("\r\n"));
www.fastrprint(F("\r\n"));
www.println();
} else {
Serial.println(F("Connection failed"));
return;
}
Serial.println(F("-------------------------------------"));
/* Read data until either the connection is closed, or the idle timeout is reached. */
unsigned long lastRead = millis();
while (www.connected() && (millis() - lastRead < IDLE_TIMEOUT_MS)) {
while (www.available()) {
char c = www.read();
Serial.print(c);
lastRead = millis();
}
}
www.close();
Serial.println(F("-------------------------------------"));
/* You need to make sure to clean up after yourself or the CC3000 can freak out */
/* the next time your try to connect ... */
Serial.println(F("\n\nDisconnecting"));
cc3000.disconnect();
}
void loop(void)
{
WildFire_CC3000_Client www = cc3000.connectTCP(ip, 80);
if (www.connected()) {
www.fastrprint(F("GET "));
www.fastrprint(WEBPAGE);
www.fastrprint(F(" HTTP/1.1\r\n"));
www.fastrprint(F("Host: "));
www.fastrprint(WEBSITE);
www.fastprint("Tstream=");
www.fastprint(analogRead(A0));
www.fastprint("&conductivity=");
www.fastprint(analogRead(A1));
www.fastprint("&depth=");
www.fastprint(analogRead(A2);
www.fastprint("&turbidity=");
www.fastprint(analogRead(A3));
www.fastrprint(F("\r\n"));
www.fastrprint(F("\r\n"));
www.println();
} else {
Serial.println(F("Connection failed"));
return;
}
delay(60000);
}
/**************************************************************************/
/*!
@brief Begins an SSID scan and prints out all the visible networks
*/
/**************************************************************************/
void listSSIDResults(void)
{
uint32_t index;
uint8_t valid, rssi, sec;
char ssidname[33];
if (!cc3000.startSSIDscan(&index)) {
Serial.println(F("SSID scan failed!"));
return;
}
Serial.print(F("Networks found: ")); Serial.println(index);
Serial.println(F("================================================"));
while (index) {
index--;
valid = cc3000.getNextSSID(&rssi, &sec, ssidname);
Serial.print(F("SSID Name : ")); Serial.print(ssidname);
Serial.println();
Serial.print(F("RSSI : "));
Serial.println(rssi);
Serial.print(F("Security Mode: "));
Serial.println(sec);
Serial.println();
}
Serial.println(F("================================================"));
cc3000.stopSSIDscan();
}
/**************************************************************************/
/*!
@brief Tries to read the IP address and other connection details
*/
/**************************************************************************/
bool displayConnectionDetails(void)
{
uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv;
if(!cc3000.getIPAddress(&ipAddress, &netmask, &gateway, &dhcpserv, &dnsserv))
{
Serial.println(F("Unable to retrieve the IP Address!\r\n"));
return false;
}
else
{
Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress);
Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.println();
return true;
}
}
| [
"petmar@gmail.com"
] | petmar@gmail.com |
c9d0f78b58d063d01cb60faa829d0be9ea0dfe09 | 61bd9ef77bc11a903069b8e409e3b535dfcf9e4f | /include/Slicer.hpp | 7f68f4457afda2c506a039094ab536e522028011 | [] | no_license | justgook/SlicerLib | 72a20c78bedc02fbde5708d9437c4169379b8488 | 3da1f03076eea47718d69920474cf727a5d3fcee | refs/heads/master | 2020-05-14T13:50:41.569374 | 2014-12-26T12:03:34 | 2014-12-26T12:03:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 869 | hpp | #ifndef __Slicer_H_
#define __Slicer_H_
#include <lua.hpp>
#include "Exception.hpp"
#include "Base.hpp"
class Slicer: public Base {
public:
Slicer(const char *filename): Base(filename, 100) {
}
std::vector<std::string> exec(const char * stlFileContents) {
std::vector<std::string> layers;
lua_getglobal(L, "exec");
if (lua_isnil(L, -1)) {
throw(Exception(100 + 3, "exec function not found"));
}
lua_pushstring(L, stlFileContents);
lua_call(L, 1, 1);
if (lua_isnil(L, -1)) {
throw(Exception(100 + 4, "exec function return nil"));
}
lua_pushnil(L);
while (lua_next(L, -2)) {
layers.push_back((std::string) lua_tostring(L, -1));
lua_pop(L, 1);
}
clean();
return layers;
};
};
#endif //__Slicer_H_
| [
"justgook@gmail.com"
] | justgook@gmail.com |
7b51608d640ca3ac359153a4423206e0cc7f72e4 | 08ed6218f7f4319d31b78e537ab91f40eca928e0 | /malloc1/main.cpp | 9dd9e067dc23d18c36fb63b4ef9ca5d7c48443ef | [] | no_license | 20141105055/malloc1 | 0d12f8164ad3fac093647b8eb11550338a90e39f | 1b4df2e6355bfac2e268fc17a57cbba8ff048634 | refs/heads/master | 2021-01-13T00:37:02.689111 | 2015-11-18T13:21:36 | 2015-11-18T13:21:36 | 46,420,097 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 676 | cpp | //
// main.cpp
// malloc1
//
// Created by 20141105055ljm on 15/11/18.
// Copyright (c) 2015年 20141105055ljm. All rights reserved.
//
#include <iostream>
//#define N 5
int main(int argc, const char * argv[]) {
// insert code here...
int *a;
int N;
int i,j,temp;
a=(int *)malloc(N*4);
for (i=0;i<N;i++)
scanf("%d",&a[i]);
for(i=0;i<N-1;i++)
{
for(j=0;j<N-1-i;j++)
{
if(a[j]>a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
for(i=0;i<N;i++)
printf("%d\n",a[i]);
return 0;
}
| [
"571836353@qq.com"
] | 571836353@qq.com |
5f61b9d061c671a4ae691a45dd92d6df4c53a888 | ad27bbc83b2e4cd4661d540e58d392b18436d78b | /operator_overload1.cpp | 8c2285d1cfe6d5f976bbffe76033170ea6f4545b | [] | no_license | sonofspring2/cpp_demo | 586a530abd469790a790c4dd65f7460ec12f989b | 4153c516b83e21f1beec0e56b48d79483352c4c9 | refs/heads/master | 2021-01-11T09:16:46.222432 | 2016-12-26T23:33:43 | 2016-12-26T23:33:43 | 77,392,293 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,525 | cpp | #include <iostream>
int gcd(int a, int b){
return b==0 ? a : gcd(b, a %b);
}
class Fraction{
private:
int m_numerator;
int m_denominator;
public:
Fraction(int numerator = 0, int denominator = 0):m_numerator(numerator),m_denominator(denominator){
}
void reduce()
{
int temp = gcd(m_numerator,m_denominator);
m_numerator /=temp;
m_denominator /=temp;
}
void print(){
std::cout << m_numerator << "/" << m_denominator << "\n" ;
}
friend Fraction operator*(const Fraction &f1, const Fraction &f2);
friend Fraction operator*(const Fraction &f1, int value);
friend Fraction operator*(int value,const Fraction &f1);
};
Fraction operator*(const Fraction &f1, const Fraction &f2)
{
int final_numerator = f1.m_numerator * f2.m_numerator;
int final_denominator = f1.m_denominator * f2.m_denominator;
Fraction f3 = Fraction(final_numerator, final_denominator);
f3.reduce();
return f3;
}
Fraction operator*(const Fraction &f1, int value)
{
int final_numerator = f1.m_numerator * value;
int final_denominator = f1.m_denominator;
Fraction f3 = Fraction(final_numerator, final_denominator);
f3.reduce();
return f3;
}
Fraction operator*(int value, const Fraction &f1)
{
// return operator*(f1,value);
return f1*value;
}
int main(){
Fraction f1(2,5);
f1.print();
Fraction f2(3,8);
f2.print();
Fraction f3 = f1 * f2;
f3.print();
Fraction f4 = f1 *2;
f4.print();
Fraction f5 = 2 * f2;
f5.print();
Fraction f6;
f6 = Fraction(1,2) * Fraction(2,3) * Fraction(3,4);
f6.print();
}
| [
"mdai3@ncsu.edu"
] | mdai3@ncsu.edu |
17e132cd6e4c9c581244c89de536b4e6e81ad836 | e297aeafc02d479ce02a73cb602d178fd22eecb7 | /bomb.h | efc5e5666a4667cf2d7e61ca9a509e85951c4c09 | [] | no_license | mbnatafgi/EECE435LProject | c04b4adfe7b208df384964b60250561806e5505c | 8c149ac315d39f45ee9f09d01ba59ec3497cfdc1 | refs/heads/master | 2022-06-03T01:19:13.770563 | 2020-04-29T01:24:47 | 2020-04-29T16:21:22 | 121,501,940 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 176 | h | #ifndef BOMB_H
#define BOMB_H
#include "weapon.h"
class Bomb: public Weapon
{
public:
Bomb(int strength);
signals:
public slots:
void update();
};
#endif // BOMB_H
| [
"billonatafji"
] | billonatafji |
52161df8510efde4acd0b9be7b56f469ca680254 | 9bdc868dbc3910ae72a05ab66cf53d30dffab2a8 | /src/script/script.cpp | cadc32dbc77c58b6e52dc25e892a836ccb9bbbfe | [
"MIT"
] | permissive | YEPCOIN/Yep-Core | 6aa8a3750e8496509501b7ff4d663a2681854c96 | 541ada7485b28abe1429c400835ce228ca9a6903 | refs/heads/master | 2020-07-03T04:44:44.361866 | 2020-05-06T19:45:05 | 2020-05-06T19:45:05 | 201,787,182 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,217 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2017-2019 The yep developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "script.h"
#include "tinyformat.h"
#include "utilstrencodings.h"
namespace {
inline std::string ValueString(const std::vector<unsigned char>& vch)
{
if (vch.size() <= 4)
return strprintf("%d", CScriptNum(vch, false).getint());
else
return HexStr(vch);
}
} // anon namespace
using namespace std;
const char* GetOpName(opcodetype opcode)
{
switch (opcode)
{
// push value
case OP_0 : return "0";
case OP_PUSHDATA1 : return "OP_PUSHDATA1";
case OP_PUSHDATA2 : return "OP_PUSHDATA2";
case OP_PUSHDATA4 : return "OP_PUSHDATA4";
case OP_1NEGATE : return "-1";
case OP_RESERVED : return "OP_RESERVED";
case OP_1 : return "1";
case OP_2 : return "2";
case OP_3 : return "3";
case OP_4 : return "4";
case OP_5 : return "5";
case OP_6 : return "6";
case OP_7 : return "7";
case OP_8 : return "8";
case OP_9 : return "9";
case OP_10 : return "10";
case OP_11 : return "11";
case OP_12 : return "12";
case OP_13 : return "13";
case OP_14 : return "14";
case OP_15 : return "15";
case OP_16 : return "16";
// control
case OP_NOP : return "OP_NOP";
case OP_VER : return "OP_VER";
case OP_IF : return "OP_IF";
case OP_NOTIF : return "OP_NOTIF";
case OP_VERIF : return "OP_VERIF";
case OP_VERNOTIF : return "OP_VERNOTIF";
case OP_ELSE : return "OP_ELSE";
case OP_ENDIF : return "OP_ENDIF";
case OP_VERIFY : return "OP_VERIFY";
case OP_RETURN : return "OP_RETURN";
// stack ops
case OP_TOALTSTACK : return "OP_TOALTSTACK";
case OP_FROMALTSTACK : return "OP_FROMALTSTACK";
case OP_2DROP : return "OP_2DROP";
case OP_2DUP : return "OP_2DUP";
case OP_3DUP : return "OP_3DUP";
case OP_2OVER : return "OP_2OVER";
case OP_2ROT : return "OP_2ROT";
case OP_2SWAP : return "OP_2SWAP";
case OP_IFDUP : return "OP_IFDUP";
case OP_DEPTH : return "OP_DEPTH";
case OP_DROP : return "OP_DROP";
case OP_DUP : return "OP_DUP";
case OP_NIP : return "OP_NIP";
case OP_OVER : return "OP_OVER";
case OP_PICK : return "OP_PICK";
case OP_ROLL : return "OP_ROLL";
case OP_ROT : return "OP_ROT";
case OP_SWAP : return "OP_SWAP";
case OP_TUCK : return "OP_TUCK";
// splice ops
case OP_CAT : return "OP_CAT";
case OP_SUBSTR : return "OP_SUBSTR";
case OP_LEFT : return "OP_LEFT";
case OP_RIGHT : return "OP_RIGHT";
case OP_SIZE : return "OP_SIZE";
// bit logic
case OP_INVERT : return "OP_INVERT";
case OP_AND : return "OP_AND";
case OP_OR : return "OP_OR";
case OP_XOR : return "OP_XOR";
case OP_EQUAL : return "OP_EQUAL";
case OP_EQUALVERIFY : return "OP_EQUALVERIFY";
case OP_RESERVED1 : return "OP_RESERVED1";
case OP_RESERVED2 : return "OP_RESERVED2";
// numeric
case OP_1ADD : return "OP_1ADD";
case OP_1SUB : return "OP_1SUB";
case OP_2MUL : return "OP_2MUL";
case OP_2DIV : return "OP_2DIV";
case OP_NEGATE : return "OP_NEGATE";
case OP_ABS : return "OP_ABS";
case OP_NOT : return "OP_NOT";
case OP_0NOTEQUAL : return "OP_0NOTEQUAL";
case OP_ADD : return "OP_ADD";
case OP_SUB : return "OP_SUB";
case OP_MUL : return "OP_MUL";
case OP_DIV : return "OP_DIV";
case OP_MOD : return "OP_MOD";
case OP_LSHIFT : return "OP_LSHIFT";
case OP_RSHIFT : return "OP_RSHIFT";
case OP_BOOLAND : return "OP_BOOLAND";
case OP_BOOLOR : return "OP_BOOLOR";
case OP_NUMEQUAL : return "OP_NUMEQUAL";
case OP_NUMEQUALVERIFY : return "OP_NUMEQUALVERIFY";
case OP_NUMNOTEQUAL : return "OP_NUMNOTEQUAL";
case OP_LESSTHAN : return "OP_LESSTHAN";
case OP_GREATERTHAN : return "OP_GREATERTHAN";
case OP_LESSTHANOREQUAL : return "OP_LESSTHANOREQUAL";
case OP_GREATERTHANOREQUAL : return "OP_GREATERTHANOREQUAL";
case OP_MIN : return "OP_MIN";
case OP_MAX : return "OP_MAX";
case OP_WITHIN : return "OP_WITHIN";
// crypto
case OP_RIPEMD160 : return "OP_RIPEMD160";
case OP_SHA1 : return "OP_SHA1";
case OP_SHA256 : return "OP_SHA256";
case OP_HASH160 : return "OP_HASH160";
case OP_HASH256 : return "OP_HASH256";
case OP_CODESEPARATOR : return "OP_CODESEPARATOR";
case OP_CHECKSIG : return "OP_CHECKSIG";
case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY";
case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG";
case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY";
// expanson
case OP_NOP1 : return "OP_NOP1";
case OP_NOP2 : return "OP_NOP2";
case OP_NOP3 : return "OP_NOP3";
case OP_NOP4 : return "OP_NOP4";
case OP_NOP5 : return "OP_NOP5";
case OP_NOP6 : return "OP_NOP6";
case OP_NOP7 : return "OP_NOP7";
case OP_NOP8 : return "OP_NOP8";
case OP_NOP9 : return "OP_NOP9";
case OP_NOP10 : return "OP_NOP10";
// zerocoin
case OP_ZEROCOINMINT : return "OP_ZEROCOINMINT";
case OP_ZEROCOINSPEND : return "OP_ZEROCOINSPEND";
case OP_INVALIDOPCODE : return "OP_INVALIDOPCODE";
// Note:
// The template matching params OP_SMALLINTEGER/etc are defined in opcodetype enum
// as kind of implementation hack, they are *NOT* real opcodes. If found in real
// Script, just let the default: case deal with them.
default:
return "OP_UNKNOWN";
}
}
unsigned int CScript::GetSigOpCount(bool fAccurate) const
{
unsigned int n = 0;
const_iterator pc = begin();
opcodetype lastOpcode = OP_INVALIDOPCODE;
while (pc < end())
{
opcodetype opcode;
if (!GetOp(pc, opcode))
break;
if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
n++;
else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
{
if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
n += DecodeOP_N(lastOpcode);
else
n += 20;
}
lastOpcode = opcode;
}
return n;
}
unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
{
if (!IsPayToScriptHash())
return GetSigOpCount(true);
// This is a pay-to-script-hash scriptPubKey;
// get the last item that the scriptSig
// pushes onto the stack:
const_iterator pc = scriptSig.begin();
vector<unsigned char> data;
while (pc < scriptSig.end())
{
opcodetype opcode;
if (!scriptSig.GetOp(pc, opcode, data))
return 0;
if (opcode > OP_16)
return 0;
}
/// ... and return its opcount:
CScript subscript(data.begin(), data.end());
return subscript.GetSigOpCount(true);
}
bool CScript::IsNormalPaymentScript() const
{
if(this->size() != 25) return false;
std::string str;
opcodetype opcode;
const_iterator pc = begin();
int i = 0;
while (pc < end())
{
GetOp(pc, opcode);
if( i == 0 && opcode != OP_DUP) return false;
else if(i == 1 && opcode != OP_HASH160) return false;
else if(i == 3 && opcode != OP_EQUALVERIFY) return false;
else if(i == 4 && opcode != OP_CHECKSIG) return false;
else if(i == 5) return false;
i++;
}
return true;
}
bool CScript::IsPayToScriptHash() const
{
// Extra-fast test for pay-to-script-hash CScripts:
return (this->size() == 23 &&
this->at(0) == OP_HASH160 &&
this->at(1) == 0x14 &&
this->at(22) == OP_EQUAL);
}
bool CScript::IsZerocoinMint() const
{
//fast test for Zerocoin Mint CScripts
return (this->size() > 0 &&
this->at(0) == OP_ZEROCOINMINT);
}
bool CScript::IsZerocoinSpend() const
{
if (this->empty())
return false;
return (this->at(0) == OP_ZEROCOINSPEND);
}
bool CScript::IsPushOnly(const_iterator pc) const
{
while (pc < end())
{
opcodetype opcode;
if (!GetOp(pc, opcode))
return false;
// Note that IsPushOnly() *does* consider OP_RESERVED to be a
// push-type opcode, however execution of OP_RESERVED fails, so
// it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
// the P2SH special validation code being executed.
if (opcode > OP_16)
return false;
}
return true;
}
bool CScript::IsPushOnly() const
{
return this->IsPushOnly(begin());
}
std::string CScript::ToString() const
{
std::string str;
opcodetype opcode;
std::vector<unsigned char> vch;
const_iterator pc = begin();
while (pc < end())
{
if (!str.empty())
str += " ";
if (!GetOp(pc, opcode, vch))
{
str += "[error]";
return str;
}
if (0 <= opcode && opcode <= OP_PUSHDATA4) {
str += ValueString(vch);
} else {
str += GetOpName(opcode);
if (opcode == OP_ZEROCOINSPEND) {
//Zerocoinspend has no further op codes.
break;
}
}
}
return str;
}
| [
"ultrapoolcom@gmail.com"
] | ultrapoolcom@gmail.com |
6f56e899900edf92c44647d6c96f4c4b8e63fd46 | 0be8bd65e0d9fd5ea4bf7be3419bd05be2d57d36 | /branches/SmartGis.1.1.vs08/src/SmtGuiCore/Dlg2DFeatureInfo.cpp | 0e3cf23911330fafa031e73bcec5ff62e44cb972 | [] | no_license | jsccl1988/smartgis | d6b8018b115f43c6542c3156b63f187995a7920c | 6c5cbdbd3d939012eebb8bd19964815b60215bb4 | refs/heads/master | 2022-12-14T09:45:54.540512 | 2022-12-07T08:43:12 | 2022-12-07T08:43:12 | 55,857,404 | 4 | 3 | null | null | null | null | GB18030 | C++ | false | false | 3,643 | cpp | // Dlg2DFeatureInfo.cpp : 实现文件
//
#include "stdafx.h"
#include "Dlg2DFeatureInfo.h"
#include "gis_attribute.h"
#include "geo_geometry.h"
#include "bl_envelope.h"
#include "smt_logmanager.h"
// CDlg2DFeatureInfo 对话框
IMPLEMENT_DYNAMIC(CDlg2DFeatureInfo, CDialog)
CDlg2DFeatureInfo::CDlg2DFeatureInfo(CWnd* pParent /*=NULL*/)
: CDialog(CDlg2DFeatureInfo::IDD, pParent)
,m_pSmtFea(NULL)
{
}
CDlg2DFeatureInfo::~CDlg2DFeatureInfo()
{
m_pSmtFea = NULL;
}
void CDlg2DFeatureInfo::DoDataExchange(CDataExchange* pDX)
{
DDX_Control(pDX,IDC_STEXT_GEOM,m_geomInfo);
DDX_Control(pDX, IDC_GRID_ATT,m_attGrid);
CDialog::DoDataExchange(pDX);
}
BEGIN_MESSAGE_MAP(CDlg2DFeatureInfo, CDialog)
ON_BN_CLICKED(IDOK, &CDlg2DFeatureInfo::OnBnClickedOk)
END_MESSAGE_MAP()
// CDlg2DFeatureInfo 消息处理程序
BOOL CDlg2DFeatureInfo::OnInitDialog()
{
CDialog::OnInitDialog();
// TODO: 在此添加额外的初始化
//return TRUE;
m_attGrid.SetTextBkColor(RGB(0xFF, 0xFF, 0xE0));
m_attGrid.SetEditable(FALSE);
if (m_pSmtFea)
{
//
UpdateGeomInfo();
//
InitAttGridHead();
UpdateAttGridContent();
}
return TRUE; // return TRUE unless you set the focus to a control
// 异常: OCX 属性页应返回 FALSE
}
void CDlg2DFeatureInfo::UpdateGeomInfo()
{
CString strGeomInfo;
SmtGeometry *pSmtGeom = m_pSmtFea->GetGeometryRef();
if (pSmtGeom->GetGeometryType() == SmtGeometryType::GTPoint)
{
SmtPoint *pPoint = (SmtPoint *)pSmtGeom;
Envelope env;
pSmtGeom->GetEnvelope(&env);
strGeomInfo.Format(" 类型:%s\n x:%f\ty:%f",pSmtGeom->GetGeometryName(),pPoint->GetX(),pPoint->GetY());
}
else
{
Envelope env;
pSmtGeom->GetEnvelope(&env);
strGeomInfo.Format(" 类型:%s\n x min:%f\ty min:%f\n x max:%f\ty max:%f",pSmtGeom->GetGeometryName(),env.MinX,env.MinY,env.MaxX,env.MaxY);
}
m_geomInfo.SetWindowText(strGeomInfo);
}
void CDlg2DFeatureInfo::InitAttGridHead()
{
m_attGrid.DeleteAllItems();
m_attGrid.SetColumnCount(3);
m_attGrid.SetRowCount(1);
m_attGrid.SetFixedRowCount(1);
m_attGrid.SetFixedColumnCount(1);
m_attGrid.SetColumnWidth(0,80); //设置列宽
m_attGrid.SetColumnWidth(1,80); //设置列宽
m_attGrid.SetColumnWidth(2,120); //设置列宽
GV_ITEM item;
item.mask = GVIF_TEXT|GVIF_FORMAT;
item.nFormat = DT_CENTER;
//属性名称
item.row = 0;
item.col = 0;
item.strText = _T("属性名称");
m_attGrid.SetItem(&item);
//属性类型
item.col++;
item.strText = _T("属性类型");
m_attGrid.SetItem(&item);
//属性值
item.col++;
item.strText = _T("属性值");
m_attGrid.SetItem(&item);
//m_attGrid.AutoSizeColumns();
}
void CDlg2DFeatureInfo::UpdateAttGridContent()
{
if (NULL == m_pSmtFea)
return ;
SmtAttribute *pAtt = m_pSmtFea->GetAttributeRef();
if (pAtt)
{
m_attGrid.SetRowCount(pAtt->GetFieldCount() + 1);
GV_ITEM item;
item.mask = GVIF_TEXT|GVIF_FORMAT;
item.nFormat = DT_CENTER;
for (int i = 0; i < pAtt->GetFieldCount();i++)
{
SmtField *pFld = pAtt->GetFieldPtr(i);
if (pFld)
{
item.row = i+1;
item.col = 0;
item.strText = pFld->GetName();
m_attGrid.SetItem(&item);
item.col++;
item.strText = SmtField::GetTypeName(pFld->GetType());
m_attGrid.SetItem(&item);
item.col++;
item.strText = pFld->GetValueAsString();
m_attGrid.SetItem(&item);
}
}
}
}
void CDlg2DFeatureInfo::OnBnClickedOk()
{
// TODO: 在此添加控件通知处理程序代码
OnOK();
}
| [
"jsccl1988@gmail.com"
] | jsccl1988@gmail.com |
1d0beb74c0f695829635bcd361db760bfab48df6 | 5431502adf171a94aa16f742428bab8ad8340c75 | /esp8266-mp3/src/time.h | 8882308396d714c58ccbb490979ef8a33f343752 | [] | no_license | mxyue/platformIO-demo | 4dcf1c89c7c06886ea763f870d68077a2164672f | 8dd4cf3f49a07487a2f7915ce42953378d3ee673 | refs/heads/master | 2022-11-19T11:31:19.386069 | 2020-07-15T06:36:27 | 2020-07-15T06:36:27 | 279,757,133 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 108 | h | #ifndef TIME_H
#define TIME_H
class Time{
public:
static void Setup();
static void Loop();
};
#endif | [
"basicbox@126.com"
] | basicbox@126.com |
8d7daf876b1a3cab96144d032c99b4346ebb845f | 44ab57520bb1a9b48045cb1ee9baee8816b44a5b | /AssistTesting/Code/Editor/TerrainEditor/TerrainEditorAssistTesting/TestingLib.cpp | 1149bee262dd0a6798d4a039a3e2e69bbab5c329 | [
"BSD-3-Clause"
] | permissive | WuyangPeng/Engine | d5d81fd4ec18795679ce99552ab9809f3b205409 | 738fde5660449e87ccd4f4878f7bf2a443ae9f1f | refs/heads/master | 2023-08-17T17:01:41.765963 | 2023-08-16T07:27:05 | 2023-08-16T07:27:05 | 246,266,843 | 10 | 0 | null | null | null | null | GB18030 | C++ | false | false | 281 | cpp | /// Copyright (c) 2010-2023
/// Threading Core Render Engine
///
/// 作者：彭武阳，彭晔恩，彭晔泽
/// 联系作者：94458936@qq.com
///
/// 标准：std:c++20
/// 版本：0.9.1.2 (2023/07/31 19:27)
#include "System/SystemLib.h"
#include "CoreTools/CoreToolsLib.h"
| [
"94458936@qq.com"
] | 94458936@qq.com |
1d4a58107ecbfe6874e7825166db7318d022f9e2 | 3bfb4db44ae9f434a7c25fdbe2cfcd637369437f | /passbutter_driver/include/passbutter_driver/stepper_command_node.hpp | a3c2918816336ba0f0e1e8c5ec8fa29ddceaea5f | [
"MIT"
] | permissive | passbutter-robot/passbutter_hw_ros | 20b8820d61a38af5871d7df8c0e29240aff0d3f5 | ed5c53f54351e430ce56fd90b30e8459cfa9d6fa | refs/heads/main | 2023-03-04T21:21:26.188169 | 2021-02-21T22:08:44 | 2021-02-21T22:08:44 | 313,076,435 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 390 | hpp | #include <rclcpp/rclcpp.hpp>
#include <example_interfaces/msg/int32.hpp>
namespace passbutter_driver
{
class StepperCommandNode : public rclcpp::Node
{
private:
rclcpp::Publisher<example_interfaces::msg::Int32>::SharedPtr _steps;
rclcpp::TimerBase::SharedPtr _timer;
int _stepCount;
bool _reverse;
void timer_callback();
public:
StepperCommandNode();
};
} | [
"manuel.meyer.extern@googlemail.com"
] | manuel.meyer.extern@googlemail.com |
1fc6b3c197c13b1621a4a61b76902c49b3ed3c49 | 18a3f93e4b94f4f24ff17280c2820497e019b3db | /BOSS/eformat/BadVersionIssue.h | d236a9c44bd0dce1fe3a7f3f4c42ce168c5ac52d | [] | no_license | jjzhang166/BOSS_ExternalLibs | 0e381d8420cea17e549d5cae5b04a216fc8a01d7 | 9b3b30f7874ed00a582aa9526c23ca89678bf796 | refs/heads/master | 2023-03-15T22:24:21.249109 | 2020-11-22T15:11:45 | 2020-11-22T15:11:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,707 | h | //Dear emacs, this is -*- c++ -*-
/**
* @file eformat/BadVersionIssue.h
* @author <a href="mailto:Andre.dos.Anjos@cern.ch">Andre DOS ANJOS</a>
* $Author: zhangy $
* $Revision: 1.1.1.1 $
* $Date: 2009/06/19 07:35:41 $
*
* @brief Exception thrown when versions do not match
*/
#ifndef EFORMAT_BADVERSIONISSUE_H
#define EFORMAT_BADVERSIONISSUE_H
#include "eformat/Issue.h"
#include <cstdlib>
#include <stdint.h>
namespace eformat {
/**
* This exception is supposed to be thrown when version problems are found
*/
class BadVersionIssue : public eformat::Issue {
public: //interface
/**
* Builds a new bad-version exception
*
* @param context The Error Reporting System context to be used to identify
* the spot where this issue was created
* @param severity The severity of this issue
* @param current The version number that this fragment has
* @param supported The version which is supposed to be supported here
*/
BadVersionIssue(const ers::Context& context, ers::severity_t severity,
uint16_t current, uint16_t supported);
/**
* Destructor virtualisation
*/
virtual ~BadVersionIssue() throw() {}
/**
* Access the current object version
*/
uint16_t current () const;
/**
* Access the supported version
*/
uint16_t supported () const;
};
}
/**
* Simplifies the use of this Issue
*
* @param current The current version you are trying to read
* @param supported The supported version by this library
*/
#define EFORMAT_BAD_VERSION(current, supported) \
eformat::BadVersionIssue(ERS_HERE, ers::error, current, supported)
#endif /* EFORMAT_BADVERSIONISSUE_H */
| [
"r.e.deboer@students.uu.nl"
] | r.e.deboer@students.uu.nl |
d45f8103b797a47f520548f85fd6b48debf2f627 | fb29a164f4faf42aa4fe33d9bf3f72e010f7bb43 | /src/HyperscanEngine.h | 912d6c194dc286e5349d4f8bf83a57d4a35790e3 | [
"BSD-2-Clause"
] | permissive | ChoiJongKwon/regexbench | 54181167fee51e5f0d95039022939c0c327def0e | 2ebb1a9bb0badcfa83f6ba0881ac7d41dd9736a7 | refs/heads/master | 2021-01-18T22:24:16.280016 | 2016-03-19T06:15:55 | 2016-03-19T06:15:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 963 | h | // -*- c++ -*-
#ifndef REGEXBENCH_HYPERSCANENGINE_H
#define REGEXBENCH_HYPERSCANENGINE_H
#include <hs/hs_compile.h>
#include <hs/hs_runtime.h>
#include "Engine.h"
namespace regexbench {
class HyperscanEngine : public Engine {
public:
HyperscanEngine();
HyperscanEngine(const HyperscanEngine &) = delete;
HyperscanEngine(HyperscanEngine &&o) : db(o.db), scratch(o.scratch) {
o.db = nullptr;
o.scratch = nullptr;
}
virtual ~HyperscanEngine();
HyperscanEngine &operator=(const HyperscanEngine &) = delete;
HyperscanEngine &operator=(HyperscanEngine &&o) {
hs_free_database(db);
db = o.db;
o.db = nullptr;
hs_free_scratch(scratch);
scratch = o.scratch;
o.scratch = nullptr;
return *this;
}
virtual void compile(const std::vector<Rule> &);
virtual bool match(const char *, size_t);
private:
hs_database_t *db;
hs_scratch_t *scratch;
hs_platform_info_t platform;
};
} // namespace regexbench
#endif
| [
"msk@dolbo.net"
] | msk@dolbo.net |
d64e8b9b56bd686e6ecf822d3c53b18074bd33e8 | 90485a9a5bac59e63151f3381bbf37a22266f042 | /MP4.Parser.Atom/MP4.ILOC.cpp | 27bbe5b4ff9d5e1973183f80f5db5855a81954e9 | [] | no_license | yodamaster/MP4Parse | e2fbd5d9a5ab25f77e64778a1233c6252222fcf2 | 2f6dfa580f8f9c71acd40feba6b01c1cd589ec5c | refs/heads/master | 2021-01-24T02:58:47.932151 | 2013-05-07T01:37:15 | 2013-05-07T01:37:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,083 | cpp | /*******************************************************************************
* Copyright (c) 2011, Jean-David Gadina <macmade@eosgarden.com>
* Distributed under the Boost Software License, Version 1.0.
*
* 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.
******************************************************************************/
/* $Id$ */
#include "MP4.ILOC.h"
using namespace MP4;
ILOC::ILOC( void )
{
this->_type.append( "ILOC" );
}
std::string ILOC::description( void )
{
std::ostringstream o;
o << "MP4 Atom: " << this->_type << "\n";
return o.str();
}
void ILOC::processData( MP4::BinaryStream * stream, size_t length )
{
stream->ignore( length );
} | [
"1875444804@qq.com"
] | 1875444804@qq.com |
e1ef1db88c0e7a7a674bba4f685de7b52edf30e6 | 5a9f6933390a0a623d7857de2098eb09e920e24b | /lab_5/3.cpp | 1e8fceb561b205680ba592efcca17855be9defe5 | [] | no_license | enderdaniil/OOP_labs | 137468539b17d54a8b771cf3e96c4f03524a58c6 | cce3734078f31f4548a65fc361586794f5f7dc50 | refs/heads/master | 2021-01-02T15:52:54.390142 | 2020-06-01T16:34:26 | 2020-06-01T16:34:26 | 239,691,455 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 729 | cpp | #include <iostream>
using namespace std;
class time
{
private:
int sec;
int hrs;
int min;
public:
time()
{
sec = 0;
hrs = 0;
min = 0;
}
time(int a, int b, int c)
{
sec = c;
min = b;
hrs = a;
}
void display()
{
cout << hrs << ":" << min << ":" << sec;
}
void add_time(time t1, time t2)
{
sec = t1.sec + t2.sec;
if (sec > 59)
{
sec -= 60;
min++;
}
min = min + t1.min + t2.min;
if (min > 59)
{
min -= 60;
hrs++;
}
hrs = hrs + t1.hrs + t2.hrs;
if (hrs > 11)
{
hrs -= 12;
}
}
};
int main()
{
const time time1(5, 59, 59);
const time time2(4, 30, 30);
time time3;
time3.add_time(time1, time2);
cout << "time3 = "; time3.display();
cout << endl;
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
5bd0b16fbf84ef46f4190f6e3621ecb250d4e887 | a04078faf89c87b81b15800c9a3d53b229c1ba20 | /estructuras/Ejercicios/10_recursividadNumPrimos.cxx | d5ba76a71cfc0ceaae66a5b367e124a833914f77 | [] | no_license | dbetm/algoritmia-programacion-y-estructuras-datos | 43f36dfbab5ae88b40cd0baec4a593850e194e03 | ce1922047c4a018f725b81834e43a75148b07780 | refs/heads/master | 2022-04-05T04:17:32.960769 | 2020-02-18T02:40:12 | 2020-02-18T02:40:12 | 67,320,653 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 748 | cxx | #include <iostream>
#include <cstdlib>
//Recursividad
using namespace std;
class Primo {
private:
public:
Primo();
bool esPrimo(int, int);
~Primo();
};
Primo::Primo() {}
bool Primo::esPrimo(int num, int divisor) {
if(num == 1) return false;
if(num == 2) return true;
if(divisor == 1) return true;
if(divisor < num and divisor > 1) {
if(num % divisor == 0) return false;
}
return esPrimo(num, divisor - 1);
}
Primo::~Primo() {}
int main(int argc, char const *argv[]) {
int num;
Primo Px;
system("clear");
cout << "Dame un número: ";
cin >> num;
if(Px.esPrimo(num, num)) cout << "Es primo" << endl;
else cout << "No es primo" << endl;
return 0;
}
| [
"davbetm@gmail.com"
] | davbetm@gmail.com |
2e4a3c335020952cf0fc1cbd75e1772ed7e42741 | 17df2fb9dc2d6dbddff8fd4262db74d1c5c6bab5 | /netease/major/05_dp/strategy/new/FRTax.cpp | 4a0f1232977e05beef0ad56069b4871faf2c61ab | [] | no_license | mumingv/cpp | 248a786e1a554a16c179a271ff630594e24e8639 | 8db212d4ea814449a489e11618385efc94e86a06 | refs/heads/master | 2020-04-06T14:12:51.421153 | 2016-12-04T10:59:13 | 2016-12-04T10:59:13 | 52,728,536 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 157 | cpp | #include <iostream>
#include "FRTax.h"
using namespace std;
// 法国的税
double FRTax::Calculate() {
cout << "Calculate called in FRTax" << endl;
}
| [
"mumingv@163.com"
] | mumingv@163.com |
ff3fbb6cc80378cf51253faaf820ecbc3e2d7dd9 | 19194c2f2c07ab3537f994acfbf6b34ea9b55ae7 | /android-32/android/widget/AbsListView_LayoutParams.def.hpp | c4ac5f8c6fc17def0eb7c0fb16944ff6d958c276 | [
"GPL-3.0-only"
] | permissive | YJBeetle/QtAndroidAPI | e372609e9db0f96602da31b8417c9f5972315cae | ace3f0ea2678967393b5eb8e4edba7fa2ca6a50c | refs/heads/Qt6 | 2023-08-05T03:14:11.842336 | 2023-07-24T08:35:31 | 2023-07-24T08:35:31 | 249,539,770 | 19 | 4 | Apache-2.0 | 2022-03-14T12:15:32 | 2020-03-23T20:42:54 | C++ | UTF-8 | C++ | false | false | 947 | hpp | #pragma once
#include "../view/ViewGroup_LayoutParams.def.hpp"
namespace android::content
{
class Context;
}
namespace android::view
{
class ViewGroup_LayoutParams;
}
namespace android::widget
{
class AbsListView_LayoutParams : public android::view::ViewGroup_LayoutParams
{
public:
// Fields
// QJniObject forward
template<typename ...Ts> explicit AbsListView_LayoutParams(const char *className, const char *sig, Ts...agv) : android::view::ViewGroup_LayoutParams(className, sig, std::forward<Ts>(agv)...) {}
AbsListView_LayoutParams(QJniObject obj) : android::view::ViewGroup_LayoutParams(obj) {}
// Constructors
AbsListView_LayoutParams(android::view::ViewGroup_LayoutParams arg0);
AbsListView_LayoutParams(android::content::Context arg0, JObject arg1);
AbsListView_LayoutParams(jint arg0, jint arg1);
AbsListView_LayoutParams(jint arg0, jint arg1, jint arg2);
// Methods
};
} // namespace android::widget
| [
"YJBeetle@gmail.com"
] | YJBeetle@gmail.com |
9539c47027b2a60a5de27e71f0481dc6934b74e2 | 9546b2c00eaefbe9eb57f4f14711214b2009dc3b | /ChronoEngine/src/unit_FEA/ChElementHexa_20.cpp | a1d250ce88734c77ffcc7a75d2fbe584c8524752 | [
"BSD-3-Clause"
] | permissive | globus000/cew | 671096366385805a8f4dbe2d2f8c185edb4163cb | 13d2a3c007239c8caccab2c5198ef5e8147369e1 | refs/heads/master | 2016-09-05T09:18:55.011986 | 2015-04-26T16:45:00 | 2015-04-26T16:45:00 | 34,566,328 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 343 | cpp | #include "ChElementHexa_20.h"
namespace chrono
{
namespace fea
{
ChElementHexa_20::ChElementHexa_20()
{
nodes.resize(20);
this->StiffnessMatrix.Resize(60,60);
this->ir = new ChGaussIntegrationRule;
this->SetDefaultIntegrationRule();
}
ChElementHexa_20::~ChElementHexa_20()
{
}
} // END_OF_NAMESPACE____
} // END_OF_NAMESPACE____
| [
"zr_contact@mail.ru"
] | zr_contact@mail.ru |
fbe11dd6e55a7411bbbc514399b2487e801f4930 | df4801ee18b4e2d3e3cf71c7191bf5d75db38cb9 | /Util/IDTriple.cpp | 1e0b7329df7877b1baa963abbfde25354145b627 | [
"BSD-3-Clause"
] | permissive | pkumod/gStore | 86660495e14ec0880c4d652fff561bcebbea3573 | a31e2c256afbfd2035f4abddaeee8948178ae8ca | refs/heads/1.0 | 2023-07-24T00:29:22.814664 | 2023-07-13T15:13:00 | 2023-07-13T15:13:00 | 26,917,250 | 564 | 178 | BSD-3-Clause | 2022-10-05T06:46:26 | 2014-11-20T14:59:01 | C++ | UTF-8 | C++ | false | false | 692 | cpp |
#include "IDTriple.h"
bool IDTriple::operator < (const IDTriple& a) const
{
if(this->subject < a.get_subject()) return true;
else if(this->subject > a.get_subject()) return false;
else
{
if(this->predicate < a.get_predicate()) return true;
else if(this->predicate > a.get_predicate()) return false;
else
{
if(this->object <= a.get_object()) return true;
else if(this->object > a.get_object()) return false;
}
}
}
bool IDTriple::operator > (const IDTriple& a) const
{
return !(*this < a );
}
bool IDTriple::operator = (const IDTriple& a) const
{
return (this->subject == a.get_subject() && this->predicate == a.get_predicate() && this->object == a.get_object());
}
| [
"liwenjiehn@pku.edu.cn"
] | liwenjiehn@pku.edu.cn |
53204ccc3b76f67110a21f621cf18e982cd1e6b4 | cfee198c3ec5225249fa2cdc66d1639c631c2b3f | /src/core/visual/win32/krmovie/ogg/AutoAnxSeekTable.h | 1793272d6bda184c572ab997689cc3f28b9af5c5 | [
"FTL",
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-unknown-license-reference",
"Libpng",
"Zlib",
"Apache-2.0",
"BSD-2-Clause-Views",
"BSD-2-Clause",
"BSD-3-Clause"
] | permissive | unlimit999/krkrz | adb1948797f668f2d225c4c66c39ac86292ac9df | 627bd42b67943071874a5fe1a9645b021bd6bc99 | refs/heads/master | 2021-01-15T14:24:40.775799 | 2016-04-26T13:39:08 | 2016-04-26T13:39:08 | 57,589,538 | 1 | 0 | null | 2016-05-01T07:47:12 | 2016-05-01T07:47:11 | null | UTF-8 | C++ | false | false | 715 | h | #pragma once
#include <libOOOggSeek.h>
#include <AutoOggSeekTable.h>
#include <string>
using namespace std;
class AutoAnxSeekTable : public AutoOggSeekTable
{
public:
#ifdef UNICODE
AutoAnxSeekTable(wstring inFileName);
#else
AutoAnxSeekTable(string inFileName);
#endif
virtual ~AutoAnxSeekTable(void);
//virtual bool buildTable();
//IOggCallback interface
virtual bool acceptOggPage(OggPage* inOggPage);
protected:
unsigned long mAnxPackets;
bool mSeenAnything;
unsigned long mAnnodexSerialNo;
bool mReadyForOgg;
bool mSkippedCMML;
unsigned short mAnnodexMajorVersion;
// V3-related member variables
unsigned long mCMMLSerialNo;
unsigned long mCMMLPacketsToSkip;
fstream mDebugFile;
};
| [
"info@kaede-software.com"
] | info@kaede-software.com |
5fc65d7fc0dd98cf59ab9ad741b8f39f747afdfd | 386687b3b39ba50e1fb57f1a5a62dc77c532af92 | /kern/drv/ahci/port/common.hpp | e978e121014bb38b97e4a83c496c724932373898 | [
"MIT"
] | permissive | SmartPolarBear/project-dionysus | cdb0c27a591416a84d9c97363b2d83fb79e856b3 | ec0f8aa3aa307b8e81dd06dc2d24669937df747d | refs/heads/master | 2022-02-13T15:48:17.610980 | 2022-01-24T14:45:11 | 2022-01-24T14:45:11 | 208,278,970 | 31 | 1 | MIT | 2022-01-24T06:34:39 | 2019-09-13T14:16:41 | C++ | UTF-8 | C++ | false | false | 316 | hpp | #pragma once
#include "system/types.h"
#include "system/memlayout.h"
#include "system/pmm.h"
#include "drivers/ahci/ahci.hpp"
#include "drivers/ahci/ata/ata.hpp"
#include "drivers/ahci/ata/ata_string.hpp"
#include "drivers/ahci/atapi/atapi.hpp"
error_code common_identify_device(ahci::ahci_port* port, bool atapi); | [
"clevercoolbear@outlook.com"
] | clevercoolbear@outlook.com |
d20b3534fa0b60547854dcfb2a256aca7de4303b | 5913c04d5cb74fe331cf8f401a33e6aa5b1cc9f5 | /CSCI2275/HW/HW2/assignment2.cpp | 8a728431787c2b17bc1a424c3919c508436e67ac | [] | no_license | Andrew123098/LearningCpp | 830708090ba7351283b34f0489e1600551f45e80 | 02913191e62f5850f6e7dba10a816c1b5029c512 | refs/heads/master | 2023-01-31T23:55:02.197646 | 2020-12-13T06:41:39 | 2020-12-13T06:41:39 | 291,550,446 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,360 | cpp | /* Andrew Brown / 9/10/2020 / HW2 / CSCI 2275 / Dr. Rhonda Hoenigman */
/*input
garageSale.txt
*/
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include "MessageBoard.h"
using namespace std;
// Main function run
int main(int argc, char *argv[])
{
MessageBoard mb; // C1
string filename = argv[1]; // C2
// TO DO
// Get input from the user for the filename and process all items here
// After file processed, print menu and wait for user input
mb.readFile(filename);
mb.printItemsRemaining();
std::string dmenu = "======Main Menu=====\n"
"1. Post item for sale\n"
"2. Post item wanted\n"
"3. Print message board\n"
"4. Quit";
int choice;
bool exit = false;
cout << dmenu << endl;
while(cin >> choice) {
// flush the newlines and other characters
cin.clear();
cin.ignore();
switch (choice) {
case 1:
{
//get info for item for sale
//call mb.PostItemToMessageBoard
string name;
int price;
cout<<"Enter Item: ";
cin>>name;
cout<<endl;
cout<<"Enter Price as Integer: ";
cin>>price;
cout<<endl;
mb.postItemToMessageBoard(name, price, 0);
break;
}
case 2:
{
//get info for item wanted
//call mb.PostItemToMessageBoard
string name;
int price;
cout<<"Enter Item: ";
cin>>name;
cout<<endl;
cout<<"Enter Price as Integer: ";
cin>>price;
cout<<endl;
mb.postItemToMessageBoard(name, price, 1);
break;
}
case 3:
{
//print items in message board
mb.printItemsRemaining();
break;
}
case 4:
{
exit = true;
break;
}
}
if (exit) {
break;
}
cout << dmenu << endl;
}
return 0;
}
| [
"andrewb1230@gmail.com"
] | andrewb1230@gmail.com |
eb037c901b42c30ce30e4cc067c4fd8fb0807c58 | a5ab1c1743fa0472198ac834b83101ef1289c445 | /人脸检测/ProDlg.cpp | 50523153026d8d0c595ae30ad95a69d1406b79db | [] | no_license | ywydigital/FaceDetection | 391e1db0d8a9ce7261622a0e5afe13715eb03c54 | 072efa379a01b55b8901242d40842f468527d3d7 | refs/heads/master | 2021-01-25T03:19:57.399849 | 2015-04-27T15:50:39 | 2015-04-27T15:50:39 | 34,673,997 | 0 | 1 | null | null | null | null | GB18030 | C++ | false | false | 528 | cpp | // ProDlg.cpp : 实现文件
//
#include "stdafx.h"
#include "Face.h"
#include "ProDlg.h"
#include "afxdialogex.h"
// CProDlg 对话框
IMPLEMENT_DYNAMIC(CProDlg, CDialogEx)
CProDlg::CProDlg(CWnd* pParent /*=NULL*/)
: CDialogEx(CProDlg::IDD, pParent)
{
}
CProDlg::~CProDlg()
{
}
void CProDlg::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
}
void CProDlg::OnOK()
{
DestroyWindow();
CDialogEx::OnOK();
}
BEGIN_MESSAGE_MAP(CProDlg, CDialogEx)
END_MESSAGE_MAP()
// CProDlg 消息处理程序
| [
"ying930628@163.com"
] | ying930628@163.com |
43526196730c7e8f8a326bf52abf6bd873dc3e0e | ff09ffc4064ddcb1b042ece3dd25c3b04e3f1de3 | /rasterizer_fast.h | 595b95996255d989472811ddbaa0195f7645528d | [
"MIT"
] | permissive | ZhenwenHe/voxelizer | 3aa02be8061284c3345b13d1d5cc833b3790262e | 351bb5f56672d283ce08a1f9dccfc20725c2bdb9 | refs/heads/master | 2023-04-04T09:20:56.645034 | 2021-04-10T16:36:26 | 2021-04-10T16:38:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,708 | h | #pragma once
#include "polyhedron/mesh/polyhedron.h"
#include "polyhedron/glm_ext/glm_extensions.h"
#include "index_buffer.h"
#include "raster_results.h"
#include "checks.h"
#include "buffer.h"
#include "timer.h"
#include <set>
#include <unordered_set>
#include <omp.h>
namespace rasterize {
//! generates a voxel mesh from an arbitrary polyhedron
//! is very fast but memory consumption does not so scale well
//! because we use a search array and allocate complete a 3d buffer
template<typename base_t = float>
class solid_fast {
using id_t = typename mesh::polyhedron<base_t>::index_t;
mesh::polyhedron<base_t> _polyhedron;
glm::ivec3 _dim;
buffer3d<mesh::face<id_t>> _xy_plane_buffer;
buffer3d<mesh::face<id_t>> _yz_plane_buffer;
buffer3d<mesh::face<id_t>> _xz_plane_buffer;
size_t seed_size = 128;
glm::ivec3 _seed = {0, 0, 0};
// casts rays along a world coordinate plane: xy, yz, xz
// faster then checking every cell, but causing issues with infill
template <swizzle_mode mode> void planar_raycast(auto &buf) {
benchmark::timer tmp("planar_raycast()");
glm::ivec2 dim;
if constexpr(mode == yzx)
dim = {_dim.y,_dim.z};
if constexpr(mode == xzy)
dim = {_dim.x,_dim.z};
if constexpr(mode == xyz)
dim = {_dim.x,_dim.y};
#pragma omp parallel for
for(int i = 0; i < dim.x; i++)
for(int j = 0; j < dim.y; j++) {
std::set<int> inters;
if constexpr(mode == yzx)
inters = checks::raycast::get_intersections_fast<mode>(glm::vec2(i,j), _polyhedron._vertices, _yz_plane_buffer[i][j]);
if constexpr(mode == xzy)
inters = checks::raycast::get_intersections_fast<mode>(glm::vec2(i,j), _polyhedron._vertices, _xz_plane_buffer[i][j]);
if constexpr(mode == xyz)
inters = checks::raycast::get_intersections_fast<mode>(glm::vec2(i,j), _polyhedron._vertices, _xy_plane_buffer[i][j]);
bool is_in = false;
int from = -1;
for(int inters : inters) {
// 1) assign shell voxels
if constexpr(mode == yzx) {
inters = constrain(0, _dim.x-1, inters);
buf._voxels[inters][i][j] = voxel_type::shell;
}
if constexpr(mode == xzy) {
inters = constrain(0, _dim.y-1, inters);
buf._voxels[i][inters][j] = voxel_type::shell;
}
if constexpr(mode == xyz) {
inters = constrain(0, _dim.z-1, inters);
buf._voxels[i][j][inters] = voxel_type::shell;
}
// 2) assign interior voxels by bit shift
// here we run from shell voxel to shell voxel
// after three bit shifts the voxel is equal to voxel_type::interior
if(from > -1) {
for(int k = from; k < inters; k++) {
if(!is_in) continue;
if constexpr(mode == yzx) {
uint8_t &vox = buf._voxels[k][i][j];
if(vox == voxel_type::shell) continue;
vox = (vox != 0) ? vox << 1 : 1;
}
else if constexpr(mode == xzy) {
uint8_t &vox = buf._voxels[i][k][j];
if(vox == voxel_type::shell) continue;
vox = (vox != 0) ? vox << 1 : 1;
}
else if constexpr(mode == xyz) {
uint8_t &vox = buf._voxels[i][j][k];
if(vox == voxel_type::shell) continue;
vox = (vox != 0) ? vox << 1 : 1;
}
// save some voxel positions as seeds and try to space them a bit
bool seed_valid = buf._voxels[_seed.x][_seed.y][_seed.z] == voxel_type::interior;
if(!seed_valid) {
glm::ivec3 pos;
if constexpr(mode == yzx) pos = {k,i,j};
if constexpr(mode == xzy) pos = {i,k,j};
if constexpr(mode == xyz) pos = {i,j,k};
_seed = pos;
}
}
}
from = inters+1;
is_in = !is_in;
}
}
}
public:
using voxel_data_t = raster_results<buffer3d<uint8_t>, mesh::polyhedron<base_t>>;
solid_fast(const mesh::polyhedron<base_t> &poly, glm::ivec3 dim) {
double min_face_area = poly.avg_face_area() / 10;
_polyhedron = prepare_index_buffers(poly, dim, _xy_plane_buffer, _yz_plane_buffer, _xz_plane_buffer, min_face_area);
_dim = glm::ceil(_polyhedron.dim());
}
voxel_data_t rasterize() {
benchmark::timer tmp("rasterize()");
voxel_data_t buf(_dim, buffer3d<uint8_t>(_dim.x, _dim.y, _dim.z, 0), _polyhedron);
planar_raycast<yzx>(buf);
planar_raycast<xzy>(buf);
planar_raycast<xyz>(buf);
return buf;
}
};
};
| [
"dgdanielf@gmail.com"
] | dgdanielf@gmail.com |
a625e2f0aa2c454310e282068b83cf1c459d9cf9 | e70316f88b896d51a4820993b63bd3a575b849ec | /CodeGeneration/generator/else_expr.hpp | 03645cc4edcc851b52908d4ef6d5612289141089 | [
"Unlicense"
] | permissive | tedi21/SisypheReview | 0e634a2f24a3eb464dab3c050b7337462d0c8442 | a3eb490bf7d049e54ce845d4b4ae6da156927cd2 | refs/heads/master | 2023-02-09T08:11:52.522055 | 2022-07-31T16:09:22 | 2022-07-31T16:10:21 | 61,547,357 | 0 | 0 | Unlicense | 2023-02-04T12:00:11 | 2016-06-20T12:50:37 | C | ISO-8859-2 | C++ | false | false | 813 | hpp | /**
* @class else_expr
* @date 15/10/2012
* @author Teddy DIDÉ
* @version 2.0
* @brief
*/
#ifndef ELSE_EXPR_HPP
#define ELSE_EXPR_HPP
#include "if_generator.hpp"
#include "condition.hpp"
namespace gen {
class else_expr
: public cond_expr < else_expr >
{
public:
template <class T__>
struct declare_context
{
typedef typename T__::context_t context_t;
static condition<T__>& else_condition()
{
static condition<T__> instance;
return instance;
}
};
else_expr()
{}
template <typename DataT>
bool
evaluate(TYPE_CONTEXT(DataT) & c) const;
};
inline else_expr
else_g();
}
#include "impl/else_expr_impl.hpp"
#endif
| [
"teddy.dide@gmail.com"
] | teddy.dide@gmail.com |
c4a752423d07f71634a81a3dbb7e637232c06d87 | 17bced0d17c54b4eb98a457e22ede2e764143ee0 | /FTP.cpp | c794f39df228a6e73175c9d3052dc1efd110dfed | [] | no_license | DogAddan/FTPClient | 073604715af0c92e37744e18d921dc14e991b9e3 | f6b3766ccb51bea57a3df4b3a5395ac2597fc0e7 | refs/heads/master | 2020-05-02T20:31:42.605513 | 2019-03-28T12:28:59 | 2019-03-28T12:28:59 | 178,194,363 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,917 | cpp | #include "FTP.h"
#include <iostream>
#include <fstream>
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>
using namespace std;
//连接FTP服务器
void FTP::linkServer(void)
{
//发送用户名
socketSend->sendMsg("USER %s\n","EOS1811");
//接收
socketSend->recvMsg();
//发送密码
socketSend->sendMsg("PASS %s\n","ooss1811");
//接收
socketSend->recvMsg();
}
//获取新端口
void FTP::getNewPort(void)
{
//PASV
socketSend->sendMsg("PASV\n");
//接收新的端口号
string str;
socketSend->recvMsg(str);
//解析端口号
unsigned char port1,port2;
sscanf(str.c_str(),"227 Entering Passive Mode (%*d,%*d,%*d,%*d,%hhu,%hhu)",&port1,&port2);
short port = port1*256+port2;
qDebug("正在打开数据连接 IP: 192.168.6.66 端口: %hd\n",port);
//连接新端口
delete socketRecv;
try{
socketRecv = new Socket(port,"192.168.6.66");
}catch(const char* ex){
throw ex;
}
}
//执行ls命令
void FTP::commandLs(string& str)
{
//获取新端口
try{
getNewPort();
}catch(const char* ex){
throw ex;
}
//发送LIST命令
socketSend->sendMsg("LIST -al\n");
//接收
socketSend->recvMsg();
//接收
socketSend->recvMsg();
//接收文件信息
str.clear();
while(socketRecv->recvMsg(str)>0);
}
//cd
void FTP::commandCd(const string &commandStr)
{
//提取文件路径
char temp[1024] = {};
sscanf(commandStr.c_str(),"cd %s",temp);
//CWD命令
socketSend->sendMsg("CWD %s\n",temp);
//接收
socketSend->recvMsg();
//PWD命令
socketSend->sendMsg("PWD\n");
//接收
socketSend->recvMsg();
}
//cd
void FTP::commandCd(const string &commandStr,string& str)
{
//提取文件路径
char temp[1024] = {};
sscanf(commandStr.c_str(),"cd %s",temp);
//CWD命令
socketSend->sendMsg("CWD %s\n",temp);
//接收
socketSend->recvMsg();
//PWD命令
getPWD(str);
}
//pwd
void FTP::getPWD(string& str)
{
//PWD命令
socketSend->sendMsg("PWD\n");
//接收
socketSend->recvMsg(str);
qDebug() << str.c_str();
str.erase(0,5);
str.resize(str.size()-3);
}
//get
void FTP::commandGet(const string& commandStr)
{
//提取文件路径
char temp[1024] = {};
sscanf(commandStr.c_str(),"get %s",temp);
//TYPE命令
socketSend->sendMsg("TYPE I\n");
//接收
socketSend->recvMsg();
string str;
//SIZE命令
socketSend->sendMsg("SIZE %s\n",temp);
//接收
socketSend->recvMsg(str);
cout << str;
if(0 == str.find("550"))return;
//MDTM命令
socketSend->sendMsg("MDTM %s\n",temp);
//接收
str.clear();
socketSend->recvMsg(str);
cout << str;
// char *time = str.c_str();
// int year,month,day,hour,min,sec;
//获取新端口
try{
getNewPort();
}catch(const char* ex){
throw ex;
}
//RETR命令
socketSend->sendMsg("RETR %s\n",temp);
//接收文件
str.clear();
while(socketRecv->recvMsg(str) > 0);
//写文件
ofstream ofs (temp,ios::out);
ofs.write(str.c_str(),str.size());
//接收
socketSend->recvMsg();
//接收
socketSend->recvMsg();
}
//put
void FTP::commandPut(const string& commandStr)
{
//提取文件路径
char temp[1024] = {};
sscanf(commandStr.c_str(),"put %s",temp);
/*sprintf(buf,"TYPE A");
printf("%s",buf);
send(sockfd,buf,strlen(buf),0);
bzero(buf,sizeof(buf));
recv(sockfd,buf,sizeof(buf),0);
printf("service:%s",buf);*/
//SIZE命令
socketSend->sendMsg("SIZE %s\n",temp);
//接收
socketSend->recvMsg();
//获取新端口
try{
getNewPort();
}catch(const char* ex){
throw ex;
}
//读文件
char file[4096] = {};
int fd = open(temp,O_EXCL | O_RDWR,0744);
if(0 > fd)
{
perror("open");
return;
}
read(fd,file,sizeof(file));
char time[255] = {};
struct stat state = {};
fstat(fd,&state);
struct tm* stu = localtime(&(state.st_mtime));
sprintf(time,"%d%02d%02d%02d%02d%2d",(stu->tm_year)+1900,(stu->tm_mon)+1,stu->tm_mday,stu->tm_hour,stu->tm_min,stu->tm_sec);
//printf("%s\n",time);
close(fd);
//STOR命令
socketSend->sendMsg("STOR %s\n",temp);
//接收
socketSend->recvMsg();
//发送文件
socketRecv->sendMsg(file);
//
delete socketRecv;
socketRecv = NULL;
qDebug("delete socketRecv");
//接收
//socketRecv->recvMsg();
/*sprintf(buf,"PWD\n");
send(sockfd,buf,strlen(buf),0);
bzero(buf,sizeof(buf));
recv(sockfd,buf,sizeof(buf),0);
char path[4096] = {};
sscanf(buf,"257 %s",path);
printf("--%s\n",path);
printf("--%s\n",time);
printf("--%s\n",temp);*/
//MDTM命令
char buf[4096] = {};
sprintf(buf,"MDTM %s ./%s\n",time,temp);
socketSend->sendMsg(buf);
//接收
socketSend->recvMsg();
}
//put
void FTP::commandPut(const string& filePath,const string& fileName)
{
//SIZE命令
socketSend->sendMsg("SIZE %s\n",filePath.c_str());
//接收
socketSend->recvMsg();
//获取新端口
try{
getNewPort();
}catch(const char* ex){
throw ex;
}
//读文件
char file[4096] = {};
int fd = open(filePath.c_str(),O_EXCL | O_RDWR,0744);
if(0 > fd)
{
perror("open");
return;
}
read(fd,file,sizeof(file));
char time[255] = {};
struct stat state = {};
fstat(fd,&state);
struct tm* stu = localtime(&(state.st_mtime));
sprintf(time,"%d%02d%02d%02d%02d%2d",(stu->tm_year)+1900,(stu->tm_mon)+1,stu->tm_mday,stu->tm_hour,stu->tm_min,stu->tm_sec);
//printf("%s\n",time);
close(fd);
//STOR命令
socketSend->sendMsg("STOR %s\n",fileName.c_str());
//接收
socketSend->recvMsg();
//发送文件
socketRecv->sendMsg(string(file));
delete socketRecv;
socketRecv = NULL;
//接收
socketSend->recvMsg();
//MDTM命令
char buf[4096] = {};
sprintf(buf,"MDTM %s ./%s\n",time,fileName.c_str());
socketSend->sendMsg(buf);
//接收
socketSend->recvMsg();
}
//bye
void FTP::commandBye(void)
{
//发送QUIT命令
socketSend->sendMsg("QUIT\n");
//接收
socketSend->recvMsg();
}
FTP::~FTP(void)
{
commandBye();
delete socketSend;
delete socketRecv;
}
FTP::FTP(int port,const char* ip_addr)
{
//创建socket
socketSend = new Socket(port,ip_addr);
socketRecv = NULL;
//接收
socketSend->recvMsg();
//连接服务器
linkServer();
//SYST命令
socketSend->sendMsg("SYST\n");
//接收
socketSend->recvMsg();
//FEAT命令
socketSend->sendMsg("FEAT\n");
//接收
socketSend->recvMsg();
//OPTS UTF8 ON命令
socketSend->sendMsg("OPTS UTF8 ON\n");
//接收
socketSend->recvMsg();
//PWD命令
socketSend->sendMsg("PWD\n");
//接收
socketSend->recvMsg();
}
| [
"1074711738@qq.com"
] | 1074711738@qq.com |
c1733188b6706d43f9cb513ae6fb080766c3c9d5 | 98c21813a931b393279c49b195fad14c0ae17e24 | /src/allocators.h | c2e5cf3beb9770043dfb669d4c4129f9279eeca0 | [
"MIT"
] | permissive | zapcard/zapcard | 67b941ba46c48c1d4e01e74587946cc03f4007b1 | daf3414dd9b9ef11b76a167d39d7b7ade4f2a2a8 | refs/heads/master | 2020-07-03T14:17:54.860546 | 2017-04-04T13:37:29 | 2017-04-04T13:37:29 | 75,870,754 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 9,044 | h | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2013 The Zapcard developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_ALLOCATORS_H
#define BITCOIN_ALLOCATORS_H
#include <map>
#include <string>
#include <string.h>
#include <boost/thread/mutex.hpp>
#include <boost/thread/once.hpp>
#include <openssl/crypto.h> // for OPENSSL_cleanse()
/**
* Thread-safe class to keep track of locked (ie, non-swappable) memory pages.
*
* Memory locks do not stack, that is, pages which have been locked several times by calls to mlock()
* will be unlocked by a single call to munlock(). This can result in keying material ending up in swap when
* those functions are used naively. This class simulates stacking memory locks by keeping a counter per page.
*
* @note By using a map from each page base address to lock count, this class is optimized for
* small objects that span up to a few pages, mostly smaller than a page. To support large allocations,
* something like an interval tree would be the preferred data structure.
*/
template <class Locker> class LockedPageManagerBase
{
public:
LockedPageManagerBase(size_t page_size):
page_size(page_size)
{
// Determine bitmask for extracting page from address
assert(!(page_size & (page_size-1))); // size must be power of two
page_mask = ~(page_size - 1);
}
~LockedPageManagerBase()
{
assert(this->GetLockedPageCount() == 0);
}
// For all pages in affected range, increase lock count
void LockRange(void *p, size_t size)
{
boost::mutex::scoped_lock lock(mutex);
if(!size) return;
const size_t base_addr = reinterpret_cast<size_t>(p);
const size_t start_page = base_addr & page_mask;
const size_t end_page = (base_addr + size - 1) & page_mask;
for(size_t page = start_page; page <= end_page; page += page_size)
{
Histogram::iterator it = histogram.find(page);
if(it == histogram.end()) // Newly locked page
{
locker.Lock(reinterpret_cast<void*>(page), page_size);
histogram.insert(std::make_pair(page, 1));
}
else // Page was already locked; increase counter
{
it->second += 1;
}
}
}
// For all pages in affected range, decrease lock count
void UnlockRange(void *p, size_t size)
{
boost::mutex::scoped_lock lock(mutex);
if(!size) return;
const size_t base_addr = reinterpret_cast<size_t>(p);
const size_t start_page = base_addr & page_mask;
const size_t end_page = (base_addr + size - 1) & page_mask;
for(size_t page = start_page; page <= end_page; page += page_size)
{
Histogram::iterator it = histogram.find(page);
assert(it != histogram.end()); // Cannot unlock an area that was not locked
// Decrease counter for page, when it is zero, the page will be unlocked
it->second -= 1;
if(it->second == 0) // Nothing on the page anymore that keeps it locked
{
// Unlock page and remove the count from histogram
locker.Unlock(reinterpret_cast<void*>(page), page_size);
histogram.erase(it);
}
}
}
// Get number of locked pages for diagnostics
int GetLockedPageCount()
{
boost::mutex::scoped_lock lock(mutex);
return histogram.size();
}
private:
Locker locker;
boost::mutex mutex;
size_t page_size, page_mask;
// map of page base address to lock count
typedef std::map<size_t,int> Histogram;
Histogram histogram;
};
/**
* OS-dependent memory page locking/unlocking.
* Defined as policy class to make stubbing for test possible.
*/
class MemoryPageLocker
{
public:
/** Lock memory pages.
* addr and len must be a multiple of the system page size
*/
bool Lock(const void *addr, size_t len);
/** Unlock memory pages.
* addr and len must be a multiple of the system page size
*/
bool Unlock(const void *addr, size_t len);
};
/**
* Singleton class to keep track of locked (ie, non-swappable) memory pages, for use in
* std::allocator templates.
*
* Some implementations of the STL allocate memory in some constructors (i.e., see
* MSVC's vector<T> implementation where it allocates 1 byte of memory in the allocator.)
* Due to the unpredictable order of static initializers, we have to make sure the
* LockedPageManager instance exists before any other STL-based objects that use
* secure_allocator are created. So instead of having LockedPageManager also be
* static-intialized, it is created on demand.
*/
class LockedPageManager: public LockedPageManagerBase<MemoryPageLocker>
{
public:
static LockedPageManager& Instance()
{
boost::call_once(LockedPageManager::CreateInstance, LockedPageManager::init_flag);
return *LockedPageManager::_instance;
}
private:
LockedPageManager();
static void CreateInstance()
{
// Using a local static instance guarantees that the object is initialized
// when it's first needed and also deinitialized after all objects that use
// it are done with it. I can think of one unlikely scenario where we may
// have a static deinitialization order/problem, but the check in
// LockedPageManagerBase's destructor helps us detect if that ever happens.
static LockedPageManager instance;
LockedPageManager::_instance = &instance;
}
static LockedPageManager* _instance;
static boost::once_flag init_flag;
};
//
// Functions for directly locking/unlocking memory objects.
// Intended for non-dynamically allocated structures.
//
template<typename T> void LockObject(const T &t) {
LockedPageManager::Instance().LockRange((void*)(&t), sizeof(T));
}
template<typename T> void UnlockObject(const T &t) {
OPENSSL_cleanse((void*)(&t), sizeof(T));
LockedPageManager::Instance().UnlockRange((void*)(&t), sizeof(T));
}
//
// Allocator that locks its contents from being paged
// out of memory and clears its contents before deletion.
//
template<typename T>
struct secure_allocator : public std::allocator<T>
{
// MSVC8 default copy constructor is broken
typedef std::allocator<T> base;
typedef typename base::size_type size_type;
typedef typename base::difference_type difference_type;
typedef typename base::pointer pointer;
typedef typename base::const_pointer const_pointer;
typedef typename base::reference reference;
typedef typename base::const_reference const_reference;
typedef typename base::value_type value_type;
secure_allocator() throw() {}
secure_allocator(const secure_allocator& a) throw() : base(a) {}
template <typename U>
secure_allocator(const secure_allocator<U>& a) throw() : base(a) {}
~secure_allocator() throw() {}
template<typename _Other> struct rebind
{ typedef secure_allocator<_Other> other; };
T* allocate(std::size_t n, const void *hint = 0)
{
T *p;
p = std::allocator<T>::allocate(n, hint);
if (p != NULL)
LockedPageManager::Instance().LockRange(p, sizeof(T) * n);
return p;
}
void deallocate(T* p, std::size_t n)
{
if (p != NULL)
{
OPENSSL_cleanse(p, sizeof(T) * n);
LockedPageManager::Instance().UnlockRange(p, sizeof(T) * n);
}
std::allocator<T>::deallocate(p, n);
}
};
//
// Allocator that clears its contents before deletion.
//
template<typename T>
struct zero_after_free_allocator : public std::allocator<T>
{
// MSVC8 default copy constructor is broken
typedef std::allocator<T> base;
typedef typename base::size_type size_type;
typedef typename base::difference_type difference_type;
typedef typename base::pointer pointer;
typedef typename base::const_pointer const_pointer;
typedef typename base::reference reference;
typedef typename base::const_reference const_reference;
typedef typename base::value_type value_type;
zero_after_free_allocator() throw() {}
zero_after_free_allocator(const zero_after_free_allocator& a) throw() : base(a) {}
template <typename U>
zero_after_free_allocator(const zero_after_free_allocator<U>& a) throw() : base(a) {}
~zero_after_free_allocator() throw() {}
template<typename _Other> struct rebind
{ typedef zero_after_free_allocator<_Other> other; };
void deallocate(T* p, std::size_t n)
{
if (p != NULL)
OPENSSL_cleanse(p, sizeof(T) * n);
std::allocator<T>::deallocate(p, n);
}
};
// This is exactly like std::string, but with a custom allocator.
typedef std::basic_string<char, std::char_traits<char>, secure_allocator<char> > SecureString;
#endif
| [
"dev@zapcard.org"
] | dev@zapcard.org |
ef915793129a4955e08c4f25e79e641b54a9592f | 64e4fabf9b43b6b02b14b9df7e1751732b30ad38 | /src/chromium/gen/gen_combined/third_party/blink/public/mojom/loader/previews_resource_loading_hints.mojom-shared.h | 1107aec7f13f4591452903f02f667a9485299f04 | [
"BSD-3-Clause"
] | permissive | ivan-kits/skia-opengl-emscripten | 8a5ee0eab0214c84df3cd7eef37c8ba54acb045e | 79573e1ee794061bdcfd88cacdb75243eff5f6f0 | refs/heads/master | 2023-02-03T16:39:20.556706 | 2020-12-25T14:00:49 | 2020-12-25T14:00:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,196 | h | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_PUBLIC_MOJOM_LOADER_PREVIEWS_RESOURCE_LOADING_HINTS_MOJOM_SHARED_H_
#define THIRD_PARTY_BLINK_PUBLIC_MOJOM_LOADER_PREVIEWS_RESOURCE_LOADING_HINTS_MOJOM_SHARED_H_
#include <stdint.h>
#include <functional>
#include <ostream>
#include <type_traits>
#include <utility>
#include "base/compiler_specific.h"
#include "base/containers/flat_map.h"
#include "mojo/public/cpp/bindings/array_data_view.h"
#include "mojo/public/cpp/bindings/enum_traits.h"
#include "mojo/public/cpp/bindings/interface_data_view.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/map_data_view.h"
#include "mojo/public/cpp/bindings/string_data_view.h"
#include "third_party/blink/public/mojom/loader/previews_resource_loading_hints.mojom-shared-internal.h"
#include "mojo/public/cpp/bindings/lib/interface_serialization.h"
#include "mojo/public/cpp/bindings/native_enum.h"
#include "mojo/public/cpp/bindings/lib/native_struct_serialization.h"
#include "base/component_export.h"
namespace blink {
namespace mojom {
class PreviewsResourceLoadingHintsDataView;
} // namespace mojom
} // namespace blink
namespace mojo {
namespace internal {
template <>
struct MojomTypeTraits<::blink::mojom::PreviewsResourceLoadingHintsDataView> {
using Data = ::blink::mojom::internal::PreviewsResourceLoadingHints_Data;
using DataAsArrayElement = Pointer<Data>;
static constexpr MojomTypeCategory category = MojomTypeCategory::STRUCT;
};
} // namespace internal
} // namespace mojo
namespace blink {
namespace mojom {
// Interface base classes. They are used for type safety check.
class PreviewsResourceLoadingHintsReceiverInterfaceBase {};
using PreviewsResourceLoadingHintsReceiverPtrDataView =
mojo::InterfacePtrDataView<PreviewsResourceLoadingHintsReceiverInterfaceBase>;
using PreviewsResourceLoadingHintsReceiverRequestDataView =
mojo::InterfaceRequestDataView<PreviewsResourceLoadingHintsReceiverInterfaceBase>;
using PreviewsResourceLoadingHintsReceiverAssociatedPtrInfoDataView =
mojo::AssociatedInterfacePtrInfoDataView<PreviewsResourceLoadingHintsReceiverInterfaceBase>;
using PreviewsResourceLoadingHintsReceiverAssociatedRequestDataView =
mojo::AssociatedInterfaceRequestDataView<PreviewsResourceLoadingHintsReceiverInterfaceBase>;
class PreviewsResourceLoadingHintsDataView {
public:
PreviewsResourceLoadingHintsDataView() {}
PreviewsResourceLoadingHintsDataView(
internal::PreviewsResourceLoadingHints_Data* data,
mojo::internal::SerializationContext* context)
: data_(data), context_(context) {}
bool is_null() const { return !data_; }
int64_t ukm_source_id() const {
return data_->ukm_source_id;
}
inline void GetSubresourcesToBlockDataView(
mojo::ArrayDataView<mojo::StringDataView>* output);
template <typename UserType>
WARN_UNUSED_RESULT bool ReadSubresourcesToBlock(UserType* output) {
auto* pointer = data_->subresources_to_block.Get();
return mojo::internal::Deserialize<mojo::ArrayDataView<mojo::StringDataView>>(
pointer, output, context_);
}
private:
internal::PreviewsResourceLoadingHints_Data* data_ = nullptr;
mojo::internal::SerializationContext* context_ = nullptr;
};
} // namespace mojom
} // namespace blink
namespace std {
} // namespace std
namespace mojo {
namespace internal {
template <typename MaybeConstUserType>
struct Serializer<::blink::mojom::PreviewsResourceLoadingHintsDataView, MaybeConstUserType> {
using UserType = typename std::remove_const<MaybeConstUserType>::type;
using Traits = StructTraits<::blink::mojom::PreviewsResourceLoadingHintsDataView, UserType>;
static void Serialize(MaybeConstUserType& input,
Buffer* buffer,
::blink::mojom::internal::PreviewsResourceLoadingHints_Data::BufferWriter* output,
SerializationContext* context) {
if (CallIsNullIfExists<Traits>(input))
return;
(*output).Allocate(buffer);
(*output)->ukm_source_id = Traits::ukm_source_id(input);
decltype(Traits::subresources_to_block(input)) in_subresources_to_block = Traits::subresources_to_block(input);
typename decltype((*output)->subresources_to_block)::BaseType::BufferWriter
subresources_to_block_writer;
const mojo::internal::ContainerValidateParams subresources_to_block_validate_params(
0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr));
mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>>(
in_subresources_to_block, buffer, &subresources_to_block_writer, &subresources_to_block_validate_params,
context);
(*output)->subresources_to_block.Set(
subresources_to_block_writer.is_null() ? nullptr : subresources_to_block_writer.data());
MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
(*output)->subresources_to_block.is_null(),
mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
"null subresources_to_block in PreviewsResourceLoadingHints struct");
}
static bool Deserialize(::blink::mojom::internal::PreviewsResourceLoadingHints_Data* input,
UserType* output,
SerializationContext* context) {
if (!input)
return CallSetToNullIfExists<Traits>(output);
::blink::mojom::PreviewsResourceLoadingHintsDataView data_view(input, context);
return Traits::Read(data_view, output);
}
};
} // namespace internal
} // namespace mojo
namespace blink {
namespace mojom {
inline void PreviewsResourceLoadingHintsDataView::GetSubresourcesToBlockDataView(
mojo::ArrayDataView<mojo::StringDataView>* output) {
auto pointer = data_->subresources_to_block.Get();
*output = mojo::ArrayDataView<mojo::StringDataView>(pointer, context_);
}
} // namespace mojom
} // namespace blink
#endif // THIRD_PARTY_BLINK_PUBLIC_MOJOM_LOADER_PREVIEWS_RESOURCE_LOADING_HINTS_MOJOM_SHARED_H_ | [
"trofimov_d_a@magnit.ru"
] | trofimov_d_a@magnit.ru |
9b836dc4d2e5c78bb756630bb15d6b48a70c0163 | 06528d98efc84b07df2a06cba9e70b350d3deb1b | /vm/virtualmemorymanager.cc | 6955b674b336352faf5437ae33248a1080761c6b | [] | no_license | nickkray/project3_170 | 4e73a0c4f460205fa7a2e0f4f072ec31d88e68bf | ae130b263a38a52e4c7ce3b9384e24fbb62e19bb | refs/heads/master | 2021-06-17T04:21:45.144712 | 2017-06-06T19:57:20 | 2017-06-06T19:57:20 | 92,564,085 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,006 | cc | /*
* VirtualMemoryManager implementation
*
* Used to facilitate demand paging through providing a means by which page
* faults can be handled and pages loaded from and stored to disk.
*/
#include <stdlib.h>
#include <machine.h>
#include "virtualmemorymanager.h"
#include "system.h"
VirtualMemoryManager::VirtualMemoryManager()
{
fileSystem->Create(SWAP_FILENAME, SWAP_SECTOR_SIZE * SWAP_SECTORS);
swapFile = fileSystem->Open(SWAP_FILENAME);
swapSectorMap = new BitMap(SWAP_SECTORS);
physicalMemoryInfo = new FrameInfo[NumPhysPages];
//swapSpaceInfo = new SwapSectorInfo[SWAP_SECTORS];
nextVictim = 0;
}
VirtualMemoryManager::~VirtualMemoryManager()
{
fileSystem->Remove(SWAP_FILENAME);
delete swapFile;
delete [] physicalMemoryInfo;
//delete [] swapSpaceInfo;
}
int VirtualMemoryManager::allocSwapSector()
{
int location = swapSectorMap->Find() * PageSize; // also marks the bit
return location;
}
/*
SwapSectorInfo * VirtualMemoryManager::getSwapSectorInfo(int index)
{
return swapSpaceInfo + index;
}
*/
void VirtualMemoryManager::writeToSwap(char *page, int pageSize,
int backStoreLoc)
{
swapFile->WriteAt(page, pageSize, backStoreLoc);
}
/*
* Page replacement with the second chance algorithm
*/
void VirtualMemoryManager::swapPageIn(int virtAddr)
{
// fprintf(stderr, "virt addr = %d\n",virtAddr);
// printf("trying to swap in\n");
TranslationEntry* currPageEntry, victimPageEntry;
FrameInfo * physPageInfo;
if(memoryManager->getNumFreePages() ==0) {//no more space available
// fprintf(stderr, "No more space available - attempting second chance algo\n");
while(true){
// fprintf(stderr, "trynna get i = %d\n",nextVictim);
FrameInfo * physPageInfo = physicalMemoryInfo + nextVictim;
// fprintf(stderr, "our pointer is chillin doe but = %d\n",physPageInfo->pageTableIndex);
TranslationEntry* victimPageEntry = getPageTableEntry(physPageInfo);
if(victimPageEntry->use){
// fprintf(stderr, "setting ->use = false\n");
victimPageEntry->use = false;
nextVictim += 1;
nextVictim = nextVictim % NumPhysPages;
}else{ //this is our vicitm
// fprintf(stderr, "found our victim~~ i = %d\n",nextVictim);
int l = physPageInfo->space->locationOnDisk[physPageInfo->pageTableIndex];
if(victimPageEntry->valid && victimPageEntry->dirty) {
char *physMemLoc = machine->mainMemory + victimPageEntry->physicalPage * PageSize;
writeToSwap(physMemLoc, PageSize, l);
}
victimPageEntry->valid = false;
physPageInfo->space = currentThread->space;
physPageInfo->pageTableIndex = virtAddr / PageSize;
currPageEntry = getPageTableEntry(physPageInfo);
currPageEntry->physicalPage = nextVictim;
// Replace page
loadPageToCurrVictim(virtAddr);
nextVictim += 1;
nextVictim = nextVictim % NumPhysPages;
return;
}
}
// fprintf(stderr, "Fatal error: No more space available\n");
// exit(1);
}
// printf("free space still avail\n");
int freePage = memoryManager->getPage();
physPageInfo = physicalMemoryInfo + freePage;
physPageInfo->space = currentThread->space;
physPageInfo->pageTableIndex = virtAddr / PageSize;
// Get translation table entry
currPageEntry = getPageTableEntry(physPageInfo);
// Find free page in memory
currPageEntry->physicalPage = freePage;
loadPageToCurrVictim(virtAddr);
return;
}
/*
* Cleanup the physical memory allocated to a given address space after its
* destructor invokes.
*/
void VirtualMemoryManager::releasePages(AddrSpace* space)
{
// printf("trying to release here\n");
for (int i = 0; i < space->getNumPages(); i++)
{
TranslationEntry* currPage = space->getPageTableEntry(i);
// int swapSpaceIndex = (currPage->locationOnDisk) / PageSize;
// SwapSectorInfo * swapPageInfo = swapSpaceInfo + swapSpaceIndex;
// swapPageInfo->removePage(currPage);
//swapPageInfo->pageTableEntry = NULL;
int l = space->locationOnDisk[i];
if (currPage->valid == TRUE)
{
//int currPID = currPage->space->getPCB()->getPID();
int currPID = space->getPCB()->getPID();
DEBUG('v', "E %d: %d\n", currPID, currPage->virtualPage);
memoryManager->clearPage(currPage->physicalPage);
physicalMemoryInfo[currPage->physicalPage].space = NULL;
}
swapSectorMap->Clear(l / PageSize);
}
}
/*
* After selecting a slot of physical memory as a victim and taking care of
* synchronizing the data if needed, we load the faulting page into memory.
*/
void VirtualMemoryManager::loadPageToCurrVictim(int virtAddr)
{
// printf("trying to load to current vic\n");
int pageTableIndex = virtAddr / PageSize;
TranslationEntry* page = currentThread->space->getPageTableEntry(pageTableIndex);
//printf("tried to get pageTableEntry\n");
char* physMemLoc = machine->mainMemory + page->physicalPage * PageSize;
int swapSpaceLoc = currentThread->space->locationOnDisk[pageTableIndex];//page->locationOnDisk;
//printf("tried to get locationOnDisk\n");
swapFile->ReadAt(physMemLoc, PageSize, swapSpaceLoc);
//printf("tried to swapFile\n");
// int swapSpaceIndex = swapSpaceLoc / PageSize;
// SwapSectorInfo * swapPageInfo = swapSpaceInfo + swapSpaceIndex;
page->valid = TRUE;
//printf("set the valid bit\n");
// swapPageInfo->setValidBit(TRUE);
// swapPageInfo->setPhysMemPageNum(page->physicalPage);
}
/*
* Helper function for the second chance page replacement that retrieves the physical page
* which corresponds to the given physical memory page information that the
* VirtualMemoryManager maintains.
* This return page table entry corresponding to a physical page
*/
TranslationEntry* VirtualMemoryManager::getPageTableEntry(FrameInfo * physPageInfo)
{
TranslationEntry* page = physPageInfo->space->getPageTableEntry(physPageInfo->pageTableIndex);
return page;
}
void VirtualMemoryManager::copySwapSector(int to, int from)
{
char sectorBuf[SectorSize];
swapFile->ReadAt(sectorBuf, SWAP_SECTOR_SIZE, from);
swapFile->WriteAt(sectorBuf, SWAP_SECTOR_SIZE, to);
}
| [
"nray@umail.ucsb.edu"
] | nray@umail.ucsb.edu |
e72d3b5a191fb42ad758458041f7ee87e0d2190e | b89f06087affcb6ecbaa325132c0bf50899b7793 | /OpenGLCodeBase/Graphics For Games/Graphics Coursework/EnjoyColladaMesh.h | 9328d608e430e79badab791b591d36ad665d2cf0 | [] | no_license | Vin-Han/OpenGL-CodeBase-Easy | 9eec2a3c8a09bb8dd4b44b7ca15ce85cd945359b | 144391eaa75211d929d34e8c571971e8291bbeca | refs/heads/master | 2021-02-05T12:30:50.748292 | 2020-02-28T14:26:34 | 2020-02-28T14:26:34 | 243,780,351 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 236 | h | #pragma once
#include "EnjoyCollada.h"
#include "../../nclgl/Mesh.h"
class EnjoyColladaMesh: public EnjoyCollada
{
public:
EnjoyColladaMesh(const char* path);
~EnjoyColladaMesh();
void Draw();
std::vector<Mesh*> ChildMeshes;
};
| [
"b9000838@newcastle.ac.uk"
] | b9000838@newcastle.ac.uk |
fe48c499e83f2b684d79b658c0f0558605583e4e | e3c0499cc58c9fbec887a2e85672d5e29588f9e0 | /opt/if_opt.h | 32f5a7b084aac47754c1d89df6d6facebd06eb31 | [
"BSD-3-Clause"
] | permissive | stevenknown/xoc | bf19fba2a7851f0c91d62846b61f12000993fa94 | 3514aaf0d742e7c1bff956f5a5e96a92102abe8a | refs/heads/master | 2023-05-14T10:18:34.851859 | 2023-04-29T08:15:24 | 2023-04-29T08:15:24 | 40,242,945 | 132 | 19 | NOASSERTION | 2023-09-08T08:04:04 | 2015-08-05T12:02:52 | C++ | UTF-8 | C++ | false | false | 4,621 | h | /*@
XOC Release License
Copyright (c) 2013-2014, Alibaba Group, All rights reserved.
compiler@aliexpress.com
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the Su Zhenyu 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 "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
author: Su Zhenyu
@*/
#ifndef _IF_OPT_H_
#define _IF_OPT_H_
namespace xoc {
//1. This moves certain 'if' nodes up in the code under
// some cirumstances that can allow the test for the if
// to be eliminated. The ``if'' nodes that are
// candidates to be hoisted are those that have a
// condition depending on only a single variable. If
// that is the case, and in the code preceeding the
// 'if' (on the same tree_node_list) there is another
// 'if' which assigns a constant to the value of that
// condition variable in either the 'then' or 'else'
// part, this will duplicate the original 'if' node and
// put it in both the 'then' and 'else' parts of the
// higher 'if' node, if this is legal. This is useful
// for code which has 'chains' of 'if' nodes; that
// is, the body of one sets a variable that is used as a
// test in a later 'if'. After hoisting, the constant
// value can often be propagated into the condition in
// one of the branches of the 'if'. In simple cases
// where the flag is cleared before the higher 'if' and
// then set only in one of its branches, the test can be
// eliminated in both parts.
//
//2. Do simple optimizations on unstructured control flow
// (branches and labels). The optimizations are done
// simultaneously in such a way that the result cannot
// benefit from any more of these optimizations -- the
// output run through this pass again will not change.
// The following optimizations are performed:
// * Labels that are not the target of any possible
// branch are removed.
// * Uses of labels that are followed by unconditional
// jumps or other labels without any intervening
// executable code are changed to uses of the last
// label that must always be executed before some
// executable code, and those labels are removed.
// * Unreachable code is removed.
// * Branches that would end up in the same place
// before any code is executed as they would if they
// were not taken are removed.
// * Conditional branches followed in the code by
// unconditional branches without any intervening
// executable code, followed without any intervening
// executable code by the label that is the target of
// the conditional branch, are changed to reverse the
// condition, change its target to that of the
// unconditional branch, and remove the conditional
// branch. That is,
//
// if (cond){
// t=1
// goto L1;
// }
// f=1
// goto L2;
// L1:
//
// is replaced by
//
// if (!cond){
// f=1
// goto L2;
// }
// t=1
// L1:
//
// 'goto L1' is removed
// (and L1 is removed if it is not a target of some
// other instruction).
typedef enum {
NOT_SIMP_IF = 0,
SIMP_IF_THEN_TYPE,
SIMP_IF_ELSE_TYPE,
} IF_TYPE;
} //namespace xoc
#endif
| [
"steven.known@gmail.com"
] | steven.known@gmail.com |
94772350ba60757c8b8fde1fb079140c1e2be0e5 | 486638f674a9154ca2afeba7fcf7cad62b93b959 | /src/DataNode.h | 721cc42b4bc222addd9660c8b3db19d19cb43682 | [] | no_license | TianfaYao/cerebro | cc071438ffee8ec4f18655fde1ea0f20679d387a | 9be17630a8075910c4f107d5caa2463326768326 | refs/heads/master | 2020-05-09T22:28:26.194603 | 2019-04-09T04:53:34 | 2019-04-09T04:53:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,480 | h | #pragma once
/** This class holds data at 1 instance of time.
Author : Manohar Kuse <mpkuse@connect.ust.hk>
Created : 27th Oct, 2018
**/
#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
//opencv
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/calib3d.hpp>
#include <cv_bridge/cv_bridge.h>
// ros
#include <ros/ros.h>
#include <ros/package.h>
// ros msg
#include <nav_msgs/Odometry.h>
#include <geometry_msgs/Pose.h>
#include <geometry_msgs/PoseWithCovariance.h>
#include <geometry_msgs/PoseStamped.h>
#include <sensor_msgs/PointCloud.h>
#include <geometry_msgs/Point32.h>
#include <sensor_msgs/Image.h>
// #include <nav_msgs/Path.h>
#include <geometry_msgs/Point.h>
#include <visualization_msgs/Marker.h>
#include <visualization_msgs/MarkerArray.h>
// Eigen
#include <Eigen/Core>
#include <Eigen/Dense>
#include <Eigen/Geometry>
using namespace Eigen;
#include <opencv2/core/eigen.hpp>
#include "utils/PoseManipUtils.h"
#include "utils/MiscUtils.h"
#include "utils/TermColor.h"
class DataNode
{
public:
DataNode( ros::Time stamp ): stamp(stamp)
{ is_key_frame = false; m_image=false; m_wTc=false;}
void setImageFromMsg( const sensor_msgs::ImageConstPtr msg ); ///< this sets the primary image
void setImageFromMsg( const sensor_msgs::ImageConstPtr msg, short cam_id ); ///< this sets additional image. multiple additional images by Node is possible by using ids
void setPoseFromMsg( const nav_msgs::OdometryConstPtr msg );
void setPointCloudFromMsg( const sensor_msgs::PointCloudConstPtr msg ); // uses msg->points[ \forall i].x, .y, .z
void setUnVnFromMsg( const sensor_msgs::PointCloudConstPtr msg );
void setUVFromMsg( const sensor_msgs::PointCloudConstPtr msg );
void setTrackedFeatIdsFromMsg( const sensor_msgs::PointCloudConstPtr msg );
void setAsKeyFrame() { is_key_frame = true; }
void unsetAsKeyFrame() { is_key_frame = false; }
// This is intended to indicate the number of tracked features from /feature_tracker.
// TODO: In the future if need be implement to save the tracked points. For now I am not retaining those
void setNumberOfSuccessfullyTrackedFeatures( int n );
int getNumberOfSuccessfullyTrackedFeatures() const;
bool isKeyFrame() const{ return (bool)is_key_frame; }
bool isImageAvailable() const { return m_image; }
bool isImageAvailable(short cam_id) const { return ((t_all_images.count(cam_id)>0)?true:false); }
bool isPoseAvailable() const { return m_wTc; }
bool isPtCldAvailable() const { return m_ptcld; }
bool isUnVnAvailable() const{ return m_unvn; }
bool isUVAvailable() const { return m_uv; }
bool isFeatIdsAvailable() const { return m_tracked_feat_ids; }
const cv::Mat& getImage() const; //< this will give out the default image.
const cv::Mat& getImage(short cam_id) const ; // this will give out the image of the cam_id. cam_id=0 will have issues. if you want the default camera image do not pass any argument, which will result in the above call.
const Matrix4d& getPose() const ;
const MatrixXd& getPoseCovariance() const ; //6x6 matrix
const MatrixXd& getPointCloud() const ; // returns a 4xN matrix
const MatrixXd& getUnVn() const ; // returns a 3xN matrix
const MatrixXd& getUV() const ; // returns a 3xN matrix
const VectorXi& getFeatIds() const; // return a N-vector
int nPts() const;
const ros::Time getT() const;
const ros::Time getT_image() const;
const ros::Time getT_image(short cam_id) const;
const ros::Time getT_pose() const;
const ros::Time getT_ptcld() const;
const ros::Time getT_unvn() const ;
const ros::Time getT_uv() const ;
// Whole Image descriptors setter and getter
void setWholeImageDescriptor( VectorXd vec );
// const VectorXd& getWholeImageDescriptor();
const VectorXd getWholeImageDescriptor(); //don't know which one is more suitated to me. :(
bool isWholeImageDescriptorAvailable() const { return m_img_desc; }
void prettyPrint();
void deallocate_all_images();
private:
const ros::Time stamp;
mutable std::mutex m;
// bool is_key_frame = false;
std::atomic<bool> is_key_frame;
// Raw Image
cv::Mat image;
ros::Time t_image;
// bool m_image=false; // TODO better make this atomic<bool>
std::atomic<bool> m_image;
// Additional Raw Images
std::map<short,cv::Mat> all_images;
std::map<short,ros::Time> t_all_images;
// Pose (odometry pose from vins estimator)
Matrix4d wTc;
MatrixXd wTc_covariance; // 6x6
ros::Time t_wTc;
// bool m_wTc=false;
std::atomic<bool> m_wTc;
// point cloud (3d data)
MatrixXd ptcld;
ros::Time t_ptcld;
std::atomic<bool> m_ptcld;
std::atomic<bool> m_ptcld_zero_pts;
// unvn - imaged points in normalized cords
MatrixXd unvn;
ros::Time t_unvn;
std::atomic<bool> m_unvn;
std::atomic<bool> m_unvn_zero_pts;
// uv - imaged points in observed cords.
MatrixXd uv;
ros::Time t_uv;
std::atomic<bool> m_uv;
std::atomic<bool> m_uv_zero_pts;
// tracked feat ids
VectorXi tracked_feat_ids;
ros::Time t_tracked_feat_ids;
std::atomic<bool> m_tracked_feat_ids;
std::atomic<bool> m_tracked_feat_ids_zero_pts;
int numberOfSuccessfullyTrackedFeatures = -1;
// Whole Image Descriptor
VectorXd img_desc;
bool m_img_desc = false;
};
| [
"mpkuse@connect.ust.hk"
] | mpkuse@connect.ust.hk |
978e33955fcbfa4867cb6223e3f5c0f302cdeb39 | 835598eebca539eab8defbdaecc9aaa8337c590e | /mpmissions/exile_server_config/config.cpp | aaba4a10ad6ddc34c6a4c48778f635fc7fcad88c | [] | no_license | evilhomer2/Exile-server-files | e87f5f4666693c08e50b67cc2083e77903a674c3 | 923b8743f67fa9e1962e679283a40ca51af27fd5 | refs/heads/master | 2020-04-08T02:36:14.106821 | 2018-11-24T15:07:31 | 2018-11-24T15:07:31 | 158,941,324 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 186,951 | cpp | /**
* config
*
* Exile Mod
* www.exilemod.com
* © 2015 Exile Mod Team
*
* This work is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
*/
class CfgPatches
{
class exile_server_config
{
requiredVersion = 0.1;
requiredAddons[] = {};
units[] = {};
weapons[] = {};
magazines[] = {};
ammo[] = {};
};
};
class CfgBuildings
{
//add
#include "CfgBuildings_Taviana.h"
};
class CfgExileEscapeLootServer
{
class LootTables
{
/*
Percental Item Group Spawn Chances of CivillianLowerClass:
ShittyMedical = 3.64%
GoodMedical = 2.73%
NiceMedical = 0.91%
SmokeGrenades = 3.64%
ShittyHandGrenades = 2.73%
GoodHandGrenades = 0.91%
SmokeTube1Rnd = 2.73%
GrenadeTube1Rnd = 1.82%
SmokeTube3Rnd = 0.91%
GrenadeTube3Rnd = 0.91%
WeaponSupressors = 0.91%
WeaponBipods = 0.91%
WeaponItems = 0.91%
UselessWeapons = 3.64%
ShittyWeapons = 2.73%
OkayWeapons = 2.73%
UsefulWeapons = 1.82%
GoodWeapons = 1.82%
NiceWeapons = 0.91%
UselessBackpacks = 2.73%
ShittyBackpacks = 2.73%
OkayBackpacks = 1.82%
UsefulBackpacks = 1.82%
GoodBackpacks = 0.91%
NiceBackpacks = 0.91%
UselessHeadgear = 3.64%
OkayHeadgear = 2.73%
GoodHeadgear = 1.82%
NiceHeadgear = 0.91%
ShittyPistols = 7.27%
GoodPistols = 3.64%
UselessUniforms = 3.64%
ShittyUniforms = 3.64%
OkayUniforms = 1.82%
UselessVests = 3.64%
ShittyVests = 1.82%
OkayVests = 1.82%
UsefulVests = 0.91%
GoodVests = 0.91%
ShittyScopes = 3.64%
OkayScopes = 3.64%
UsefulScopes = 2.73%
GoodScopes = 0.91%
Binoculars = 0.91%
Rangefinders = 0.91%
NightVisionGoggles = 0.91%
*/
CivillianLowerClass[] = {"Rangefinders", "ShittyUniforms", "ShittyScopes", "GoodMedical", "ShittyUniforms", "OkayHeadgear", "UsefulBackpacks", "ShittyMedical", "OkayUniforms", "ShittyHandGrenades", "OkayHeadgear", "GoodPistols", "UselessVests", "NiceWeapons", "OkayVests", "ShittyHandGrenades", "ShittyScopes", "GrenadeTube3Rnd", "ShittyScopes", "OkayBackpacks", "UselessUniforms", "ShittyBackpacks", "GoodPistols", "ShittyPistols", "OkayHeadgear", "GoodBackpacks", "UsefulWeapons", "ShittyPistols", "OkayWeapons", "UselessHeadgear", "ShittyVests", "UsefulBackpacks", "GoodMedical", "UsefulVests", "SmokeTube1Rnd", "UselessBackpacks", "UselessVests", "ShittyPistols", "UselessUniforms", "ShittyVests", "GrenadeTube1Rnd", "OkayScopes", "ShittyScopes", "NiceHeadgear", "UselessUniforms", "NiceMedical", "OkayWeapons", "ShittyWeapons", "Binoculars", "WeaponBipods", "OkayScopes", "UselessBackpacks", "ShittyPistols", "WeaponSupressors", "ShittyUniforms", "OkayWeapons", "UsefulScopes", "OkayBackpacks", "GoodWeapons", "GoodScopes", "ShittyPistols", "NightVisionGoggles", "ShittyPistols", "SmokeTube3Rnd", "UselessHeadgear", "UselessVests", "ShittyWeapons", "ShittyMedical", "SmokeGrenades", "ShittyPistols", "SmokeTube1Rnd", "UselessUniforms", "GoodHandGrenades", "ShittyHandGrenades", "UselessWeapons", "WeaponItems", "GoodPistols", "UselessWeapons", "ShittyBackpacks", "UsefulScopes", "UselessWeapons", "ShittyMedical", "GoodWeapons", "ShittyMedical", "GrenadeTube1Rnd", "GoodVests", "GoodHeadgear", "UselessHeadgear", "GoodPistols", "GoodHeadgear", "SmokeGrenades", "SmokeTube1Rnd", "OkayVests", "UselessHeadgear", "UselessBackpacks", "OkayUniforms", "UsefulScopes", "OkayScopes", "ShittyBackpacks", "UselessVests", "ShittyUniforms", "SmokeGrenades", "ShittyPistols", "GoodMedical", "NiceBackpacks", "UselessWeapons", "ShittyWeapons", "OkayScopes", "SmokeGrenades", "UsefulWeapons"};
/*
Percental Item Group Spawn Chances of CivillianUpperClass:
ShittyMedical = 3.64%
GoodMedical = 2.73%
NiceMedical = 0.91%
SmokeGrenades = 3.64%
ShittyHandGrenades = 2.73%
GoodHandGrenades = 0.91%
SmokeTube1Rnd = 2.73%
GrenadeTube1Rnd = 1.82%
SmokeTube3Rnd = 0.91%
GrenadeTube3Rnd = 0.91%
WeaponSupressors = 0.91%
WeaponBipods = 0.91%
WeaponItems = 0.91%
UselessWeapons = 3.64%
ShittyWeapons = 2.73%
OkayWeapons = 2.73%
UsefulWeapons = 1.82%
GoodWeapons = 1.82%
NiceWeapons = 0.91%
UselessBackpacks = 2.73%
ShittyBackpacks = 2.73%
OkayBackpacks = 1.82%
UsefulBackpacks = 1.82%
GoodBackpacks = 0.91%
NiceBackpacks = 0.91%
UselessHeadgear = 3.64%
OkayHeadgear = 2.73%
GoodHeadgear = 1.82%
NiceHeadgear = 0.91%
ShittyPistols = 7.27%
GoodPistols = 3.64%
UselessUniforms = 3.64%
ShittyUniforms = 3.64%
OkayUniforms = 1.82%
UselessVests = 3.64%
ShittyVests = 1.82%
OkayVests = 1.82%
UsefulVests = 0.91%
GoodVests = 0.91%
ShittyScopes = 3.64%
OkayScopes = 3.64%
UsefulScopes = 2.73%
GoodScopes = 0.91%
Binoculars = 0.91%
Rangefinders = 0.91%
NightVisionGoggles = 0.91%
*/
CivillianUpperClass[] = {"ShittyHandGrenades", "Rangefinders", "OkayHeadgear", "ShittyScopes", "UselessWeapons", "UsefulScopes", "ShittyVests", "ShittyUniforms", "GoodPistols", "ShittyMedical", "ShittyBackpacks", "ShittyUniforms", "OkayScopes", "GoodPistols", "GoodHeadgear", "OkayUniforms", "GrenadeTube1Rnd", "UselessBackpacks", "GoodMedical", "UsefulWeapons", "GrenadeTube3Rnd", "ShittyPistols", "ShittyPistols", "UsefulVests", "OkayHeadgear", "SmokeTube1Rnd", "NiceWeapons", "GoodMedical", "UsefulBackpacks", "UselessHeadgear", "OkayVests", "ShittyScopes", "GoodWeapons", "ShittyPistols", "GoodMedical", "ShittyWeapons", "ShittyMedical", "NiceHeadgear", "UselessWeapons", "OkayWeapons", "UselessHeadgear", "WeaponSupressors", "ShittyPistols", "ShittyWeapons", "SmokeGrenades", "UselessUniforms", "UsefulBackpacks", "GoodScopes", "UselessVests", "GoodPistols", "ShittyPistols", "ShittyVests", "GrenadeTube1Rnd", "SmokeGrenades", "NiceMedical", "ShittyWeapons", "UselessBackpacks", "ShittyPistols", "UsefulScopes", "OkayBackpacks", "OkayWeapons", "Binoculars", "OkayVests", "UsefulWeapons", "ShittyMedical", "SmokeGrenades", "WeaponBipods", "OkayWeapons", "ShittyScopes", "OkayScopes", "UselessVests", "SmokeTube3Rnd", "GoodWeapons", "ShittyUniforms", "SmokeGrenades", "OkayScopes", "ShittyBackpacks", "ShittyPistols", "GoodPistols", "GoodBackpacks", "ShittyBackpacks", "GoodHeadgear", "OkayScopes", "OkayHeadgear", "ShittyUniforms", "GoodHandGrenades", "ShittyScopes", "UselessBackpacks", "UselessVests", "ShittyPistols", "UsefulScopes", "WeaponItems", "UselessVests", "UselessWeapons", "NiceBackpacks", "OkayUniforms", "UselessUniforms", "SmokeTube1Rnd", "UselessHeadgear", "SmokeTube1Rnd", "GoodVests", "ShittyMedical", "UselessUniforms", "UselessHeadgear", "ShittyHandGrenades", "NightVisionGoggles", "OkayBackpacks", "UselessWeapons", "UselessUniforms", "ShittyHandGrenades"};
/*
Percental Item Group Spawn Chances of Shop:
ShittyMedical = 3.64%
GoodMedical = 2.73%
NiceMedical = 0.91%
SmokeGrenades = 3.64%
ShittyHandGrenades = 2.73%
GoodHandGrenades = 0.91%
SmokeTube1Rnd = 2.73%
GrenadeTube1Rnd = 1.82%
SmokeTube3Rnd = 0.91%
GrenadeTube3Rnd = 0.91%
WeaponSupressors = 0.91%
WeaponBipods = 0.91%
WeaponItems = 0.91%
UselessWeapons = 3.64%
ShittyWeapons = 2.73%
OkayWeapons = 2.73%
UsefulWeapons = 1.82%
GoodWeapons = 1.82%
NiceWeapons = 0.91%
UselessBackpacks = 2.73%
ShittyBackpacks = 2.73%
OkayBackpacks = 1.82%
UsefulBackpacks = 1.82%
GoodBackpacks = 0.91%
NiceBackpacks = 0.91%
UselessHeadgear = 3.64%
OkayHeadgear = 2.73%
GoodHeadgear = 1.82%
NiceHeadgear = 0.91%
ShittyPistols = 7.27%
GoodPistols = 3.64%
UselessUniforms = 3.64%
ShittyUniforms = 3.64%
OkayUniforms = 1.82%
UselessVests = 3.64%
ShittyVests = 1.82%
OkayVests = 1.82%
UsefulVests = 0.91%
GoodVests = 0.91%
ShittyScopes = 3.64%
OkayScopes = 3.64%
UsefulScopes = 2.73%
GoodScopes = 0.91%
Binoculars = 0.91%
Rangefinders = 0.91%
NightVisionGoggles = 0.91%
*/
Shop[] = {"GoodWeapons", "GoodMedical", "UsefulScopes", "SmokeTube1Rnd", "UselessWeapons", "GoodBackpacks", "OkayHeadgear", "GoodMedical", "SmokeGrenades", "ShittyVests", "GrenadeTube1Rnd", "ShittyMedical", "UselessBackpacks", "UselessVests", "UselessHeadgear", "UselessVests", "UsefulScopes", "OkayBackpacks", "SmokeTube3Rnd", "ShittyPistols", "ShittyPistols", "GoodHeadgear", "GoodHeadgear", "UselessVests", "UselessWeapons", "Binoculars", "SmokeTube1Rnd", "OkayHeadgear", "WeaponItems", "ShittyPistols", "OkayScopes", "UselessWeapons", "NiceWeapons", "UselessBackpacks", "ShittyWeapons", "ShittyPistols", "NiceMedical", "ShittyPistols", "GoodPistols", "ShittyUniforms", "ShittyMedical", "UselessUniforms", "ShittyHandGrenades", "UselessWeapons", "OkayVests", "ShittyMedical", "GoodPistols", "GoodPistols", "OkayWeapons", "UselessUniforms", "ShittyPistols", "UsefulWeapons", "ShittyScopes", "GoodHandGrenades", "UsefulVests", "SmokeTube1Rnd", "ShittyVests", "ShittyMedical", "OkayScopes", "SmokeGrenades", "NiceBackpacks", "OkayUniforms", "ShittyWeapons", "ShittyBackpacks", "GoodVests", "UsefulScopes", "GrenadeTube3Rnd", "UselessHeadgear", "UselessUniforms", "NightVisionGoggles", "WeaponSupressors", "SmokeGrenades", "UselessHeadgear", "GoodScopes", "OkayScopes", "OkayVests", "GrenadeTube1Rnd", "OkayWeapons", "ShittyPistols", "UselessHeadgear", "ShittyUniforms", "GoodWeapons", "UsefulWeapons", "ShittyWeapons", "ShittyPistols", "UselessUniforms", "ShittyScopes", "OkayWeapons", "UselessBackpacks", "ShittyScopes", "WeaponBipods", "UsefulBackpacks", "ShittyScopes", "UsefulBackpacks", "ShittyUniforms", "ShittyBackpacks", "OkayBackpacks", "OkayHeadgear", "GoodMedical", "UselessVests", "OkayScopes", "OkayUniforms", "Rangefinders", "ShittyHandGrenades", "ShittyUniforms", "ShittyHandGrenades", "NiceHeadgear", "SmokeGrenades", "GoodPistols", "ShittyBackpacks"};
/*
Percental Item Group Spawn Chances of Industrial:
ShittyMedical = 3.64%
GoodMedical = 2.73%
NiceMedical = 0.91%
SmokeGrenades = 3.64%
ShittyHandGrenades = 2.73%
GoodHandGrenades = 0.91%
SmokeTube1Rnd = 2.73%
GrenadeTube1Rnd = 1.82%
SmokeTube3Rnd = 0.91%
GrenadeTube3Rnd = 0.91%
WeaponSupressors = 0.91%
WeaponBipods = 0.91%
WeaponItems = 0.91%
UselessWeapons = 3.64%
ShittyWeapons = 2.73%
OkayWeapons = 2.73%
UsefulWeapons = 1.82%
GoodWeapons = 1.82%
NiceWeapons = 0.91%
UselessBackpacks = 2.73%
ShittyBackpacks = 2.73%
OkayBackpacks = 1.82%
UsefulBackpacks = 1.82%
GoodBackpacks = 0.91%
NiceBackpacks = 0.91%
UselessHeadgear = 3.64%
OkayHeadgear = 2.73%
GoodHeadgear = 1.82%
NiceHeadgear = 0.91%
ShittyPistols = 7.27%
GoodPistols = 3.64%
UselessUniforms = 3.64%
ShittyUniforms = 3.64%
OkayUniforms = 1.82%
UselessVests = 3.64%
ShittyVests = 1.82%
OkayVests = 1.82%
UsefulVests = 0.91%
GoodVests = 0.91%
ShittyScopes = 3.64%
OkayScopes = 3.64%
UsefulScopes = 2.73%
GoodScopes = 0.91%
Binoculars = 0.91%
Rangefinders = 0.91%
NightVisionGoggles = 0.91%
*/
Industrial[] = {"ShittyScopes", "ShittyPistols", "GoodMedical", "UselessHeadgear", "GoodPistols", "SmokeTube1Rnd", "SmokeGrenades", "NightVisionGoggles", "OkayUniforms", "OkayBackpacks", "OkayWeapons", "OkayScopes", "GrenadeTube3Rnd", "UselessWeapons", "UsefulBackpacks", "ShittyMedical", "ShittyWeapons", "UselessUniforms", "OkayVests", "Rangefinders", "NiceBackpacks", "GoodPistols", "UselessVests", "OkayScopes", "SmokeGrenades", "UselessVests", "GoodVests", "GoodWeapons", "UselessUniforms", "ShittyBackpacks", "ShittyPistols", "UselessUniforms", "UsefulScopes", "SmokeTube3Rnd", "ShittyScopes", "ShittyWeapons", "UselessHeadgear", "UsefulVests", "SmokeTube1Rnd", "OkayVests", "ShittyUniforms", "ShittyScopes", "OkayBackpacks", "ShittyPistols", "GoodMedical", "UselessHeadgear", "OkayScopes", "UselessBackpacks", "ShittyUniforms", "ShittyVests", "UselessBackpacks", "UsefulScopes", "WeaponBipods", "NiceMedical", "ShittyMedical", "SmokeGrenades", "ShittyWeapons", "ShittyUniforms", "GoodHeadgear", "UselessBackpacks", "UselessWeapons", "GoodPistols", "ShittyMedical", "NiceWeapons", "ShittyMedical", "GrenadeTube1Rnd", "OkayWeapons", "UsefulScopes", "WeaponSupressors", "OkayUniforms", "ShittyBackpacks", "UselessWeapons", "GoodBackpacks", "ShittyUniforms", "OkayWeapons", "UsefulWeapons", "GoodHandGrenades", "GoodMedical", "ShittyPistols", "UselessUniforms", "ShittyVests", "GoodHeadgear", "SmokeTube1Rnd", "UselessVests", "GoodPistols", "OkayHeadgear", "ShittyPistols", "ShittyHandGrenades", "GoodWeapons", "OkayHeadgear", "Binoculars", "ShittyBackpacks", "ShittyPistols", "GoodScopes", "UselessVests", "SmokeGrenades", "UsefulWeapons", "OkayHeadgear", "ShittyHandGrenades", "ShittyScopes", "OkayScopes", "NiceHeadgear", "ShittyPistols", "UselessHeadgear", "GrenadeTube1Rnd", "ShittyPistols", "ShittyHandGrenades", "WeaponItems", "UselessWeapons", "UsefulBackpacks"};
/*
Percental Item Group Spawn Chances of Factories:
ShittyMedical = 3.64%
GoodMedical = 2.73%
NiceMedical = 0.91%
SmokeGrenades = 3.64%
ShittyHandGrenades = 2.73%
GoodHandGrenades = 0.91%
SmokeTube1Rnd = 2.73%
GrenadeTube1Rnd = 1.82%
SmokeTube3Rnd = 0.91%
GrenadeTube3Rnd = 0.91%
WeaponSupressors = 0.91%
WeaponBipods = 0.91%
WeaponItems = 0.91%
UselessWeapons = 3.64%
ShittyWeapons = 2.73%
OkayWeapons = 2.73%
UsefulWeapons = 1.82%
GoodWeapons = 1.82%
NiceWeapons = 0.91%
UselessBackpacks = 2.73%
ShittyBackpacks = 2.73%
OkayBackpacks = 1.82%
UsefulBackpacks = 1.82%
GoodBackpacks = 0.91%
NiceBackpacks = 0.91%
UselessHeadgear = 3.64%
OkayHeadgear = 2.73%
GoodHeadgear = 1.82%
NiceHeadgear = 0.91%
ShittyPistols = 7.27%
GoodPistols = 3.64%
UselessUniforms = 3.64%
ShittyUniforms = 3.64%
OkayUniforms = 1.82%
UselessVests = 3.64%
ShittyVests = 1.82%
OkayVests = 1.82%
UsefulVests = 0.91%
GoodVests = 0.91%
ShittyScopes = 3.64%
OkayScopes = 3.64%
UsefulScopes = 2.73%
GoodScopes = 0.91%
Binoculars = 0.91%
Rangefinders = 0.91%
NightVisionGoggles = 0.91%
*/
Factories[] = {"OkayWeapons", "ShittyScopes", "SmokeGrenades", "OkayScopes", "ShittyPistols", "WeaponSupressors", "UselessHeadgear", "UsefulBackpacks", "UselessVests", "GrenadeTube3Rnd", "UselessWeapons", "SmokeGrenades", "UsefulWeapons", "ShittyScopes", "WeaponItems", "GrenadeTube1Rnd", "Rangefinders", "NiceWeapons", "UselessWeapons", "OkayScopes", "GoodWeapons", "ShittyMedical", "NiceBackpacks", "SmokeTube1Rnd", "OkayWeapons", "ShittyMedical", "ShittyMedical", "ShittyVests", "ShittyMedical", "OkayVests", "NiceMedical", "ShittyPistols", "NightVisionGoggles", "OkayBackpacks", "SmokeTube1Rnd", "ShittyHandGrenades", "UsefulBackpacks", "GoodScopes", "OkayUniforms", "ShittyBackpacks", "OkayBackpacks", "ShittyPistols", "UselessVests", "UsefulVests", "GrenadeTube1Rnd", "ShittyPistols", "ShittyPistols", "ShittyBackpacks", "ShittyHandGrenades", "GoodVests", "SmokeGrenades", "GoodPistols", "ShittyPistols", "GoodWeapons", "ShittyScopes", "ShittyUniforms", "UselessUniforms", "UselessUniforms", "GoodMedical", "GoodBackpacks", "UsefulWeapons", "UselessBackpacks", "OkayHeadgear", "UselessWeapons", "ShittyVests", "OkayUniforms", "ShittyScopes", "ShittyUniforms", "WeaponBipods", "SmokeTube3Rnd", "ShittyUniforms", "ShittyWeapons", "OkayWeapons", "GoodHeadgear", "GoodMedical", "GoodHandGrenades", "ShittyPistols", "UselessUniforms", "ShittyHandGrenades", "OkayScopes", "ShittyPistols", "UselessVests", "ShittyBackpacks", "ShittyUniforms", "UselessHeadgear", "UselessWeapons", "SmokeGrenades", "OkayHeadgear", "UselessUniforms", "GoodPistols", "OkayScopes", "GoodPistols", "SmokeTube1Rnd", "UselessHeadgear", "ShittyWeapons", "UselessBackpacks", "ShittyWeapons", "Binoculars", "GoodMedical", "NiceHeadgear", "UsefulScopes", "OkayHeadgear", "GoodPistols", "UsefulScopes", "GoodHeadgear", "UselessVests", "UsefulScopes", "UselessHeadgear", "UselessBackpacks", "OkayVests"};
/*
Percental Item Group Spawn Chances of VehicleService:
ShittyMedical = 3.64%
GoodMedical = 2.73%
NiceMedical = 0.91%
SmokeGrenades = 3.64%
ShittyHandGrenades = 2.73%
GoodHandGrenades = 0.91%
SmokeTube1Rnd = 2.73%
GrenadeTube1Rnd = 1.82%
SmokeTube3Rnd = 0.91%
GrenadeTube3Rnd = 0.91%
WeaponSupressors = 0.91%
WeaponBipods = 0.91%
WeaponItems = 0.91%
UselessWeapons = 3.64%
ShittyWeapons = 2.73%
OkayWeapons = 2.73%
UsefulWeapons = 1.82%
GoodWeapons = 1.82%
NiceWeapons = 0.91%
UselessBackpacks = 2.73%
ShittyBackpacks = 2.73%
OkayBackpacks = 1.82%
UsefulBackpacks = 1.82%
GoodBackpacks = 0.91%
NiceBackpacks = 0.91%
UselessHeadgear = 3.64%
OkayHeadgear = 2.73%
GoodHeadgear = 1.82%
NiceHeadgear = 0.91%
ShittyPistols = 7.27%
GoodPistols = 3.64%
UselessUniforms = 3.64%
ShittyUniforms = 3.64%
OkayUniforms = 1.82%
UselessVests = 3.64%
ShittyVests = 1.82%
OkayVests = 1.82%
UsefulVests = 0.91%
GoodVests = 0.91%
ShittyScopes = 3.64%
OkayScopes = 3.64%
UsefulScopes = 2.73%
GoodScopes = 0.91%
Binoculars = 0.91%
Rangefinders = 0.91%
NightVisionGoggles = 0.91%
*/
VehicleService[] = {"ShittyPistols", "WeaponSupressors", "GoodHandGrenades", "UselessHeadgear", "OkayWeapons", "UselessUniforms", "ShittyPistols", "GoodHeadgear", "ShittyMedical", "UselessVests", "OkayUniforms", "ShittyUniforms", "UselessVests", "GoodScopes", "UsefulScopes", "SmokeTube1Rnd", "GoodVests", "UselessHeadgear", "OkayBackpacks", "OkayUniforms", "UselessUniforms", "ShittyHandGrenades", "UsefulBackpacks", "UselessUniforms", "ShittyBackpacks", "ShittyPistols", "GoodMedical", "ShittyHandGrenades", "UsefulScopes", "ShittyScopes", "ShittyBackpacks", "OkayHeadgear", "ShittyScopes", "GoodHeadgear", "OkayVests", "GoodBackpacks", "GoodMedical", "ShittyVests", "ShittyVests", "OkayWeapons", "UselessWeapons", "UsefulWeapons", "ShittyPistols", "WeaponItems", "ShittyUniforms", "GrenadeTube1Rnd", "NightVisionGoggles", "OkayScopes", "SmokeGrenades", "GrenadeTube3Rnd", "GoodPistols", "ShittyUniforms", "ShittyWeapons", "NiceHeadgear", "ShittyPistols", "ShittyPistols", "SmokeGrenades", "OkayBackpacks", "UselessWeapons", "ShittyMedical", "SmokeTube1Rnd", "NiceBackpacks", "UselessUniforms", "GoodPistols", "ShittyBackpacks", "UsefulWeapons", "OkayScopes", "OkayWeapons", "UsefulScopes", "OkayHeadgear", "ShittyUniforms", "ShittyWeapons", "Binoculars", "GoodPistols", "ShittyHandGrenades", "UselessHeadgear", "ShittyScopes", "SmokeGrenades", "UselessWeapons", "SmokeTube3Rnd", "ShittyMedical", "OkayVests", "WeaponBipods", "NiceWeapons", "GoodMedical", "ShittyPistols", "UsefulBackpacks", "GoodPistols", "NiceMedical", "ShittyWeapons", "GoodWeapons", "OkayScopes", "UselessWeapons", "SmokeGrenades", "Rangefinders", "UselessVests", "OkayHeadgear", "UsefulVests", "OkayScopes", "UselessBackpacks", "ShittyPistols", "UselessVests", "UselessBackpacks", "UselessHeadgear", "ShittyScopes", "UselessBackpacks", "GrenadeTube1Rnd", "SmokeTube1Rnd", "ShittyMedical", "GoodWeapons"};
/*
Percental Item Group Spawn Chances of Military:
ShittyMedical = 3.64%
GoodMedical = 2.73%
NiceMedical = 0.91%
SmokeGrenades = 3.64%
ShittyHandGrenades = 2.73%
GoodHandGrenades = 0.91%
SmokeTube1Rnd = 2.73%
GrenadeTube1Rnd = 1.82%
SmokeTube3Rnd = 0.91%
GrenadeTube3Rnd = 0.91%
WeaponSupressors = 0.91%
WeaponBipods = 0.91%
WeaponItems = 0.91%
UselessWeapons = 3.64%
ShittyWeapons = 2.73%
OkayWeapons = 2.73%
UsefulWeapons = 1.82%
GoodWeapons = 1.82%
NiceWeapons = 0.91%
UselessBackpacks = 2.73%
ShittyBackpacks = 2.73%
OkayBackpacks = 1.82%
UsefulBackpacks = 1.82%
GoodBackpacks = 0.91%
NiceBackpacks = 0.91%
UselessHeadgear = 3.64%
OkayHeadgear = 2.73%
GoodHeadgear = 1.82%
NiceHeadgear = 0.91%
ShittyPistols = 7.27%
GoodPistols = 3.64%
UselessUniforms = 3.64%
ShittyUniforms = 3.64%
OkayUniforms = 1.82%
UselessVests = 3.64%
ShittyVests = 1.82%
OkayVests = 1.82%
UsefulVests = 0.91%
GoodVests = 0.91%
ShittyScopes = 3.64%
OkayScopes = 3.64%
UsefulScopes = 2.73%
GoodScopes = 0.91%
Binoculars = 0.91%
Rangefinders = 0.91%
NightVisionGoggles = 0.91%
*/
Military[] = {"OkayUniforms", "OkayBackpacks", "OkayHeadgear", "SmokeGrenades", "UselessUniforms", "ShittyHandGrenades", "NiceWeapons", "GoodMedical", "OkayUniforms", "GoodPistols", "GoodScopes", "ShittyScopes", "UsefulBackpacks", "ShittyBackpacks", "GoodHandGrenades", "UselessBackpacks", "Rangefinders", "OkayWeapons", "SmokeGrenades", "ShittyScopes", "UsefulScopes", "SmokeTube1Rnd", "GoodWeapons", "OkayWeapons", "GrenadeTube1Rnd", "UsefulScopes", "ShittyScopes", "OkayVests", "GoodPistols", "ShittyHandGrenades", "UselessBackpacks", "UselessWeapons", "ShittyUniforms", "OkayScopes", "ShittyPistols", "SmokeTube1Rnd", "UselessVests", "UsefulBackpacks", "OkayBackpacks", "WeaponSupressors", "UselessVests", "UselessVests", "SmokeGrenades", "ShittyWeapons", "ShittyVests", "ShittyBackpacks", "ShittyPistols", "GrenadeTube3Rnd", "OkayHeadgear", "ShittyMedical", "SmokeTube3Rnd", "ShittyMedical", "UselessWeapons", "ShittyBackpacks", "UsefulWeapons", "ShittyWeapons", "ShittyPistols", "GoodBackpacks", "GoodMedical", "SmokeTube1Rnd", "WeaponBipods", "OkayScopes", "NiceMedical", "GoodPistols", "OkayScopes", "OkayScopes", "NightVisionGoggles", "GoodPistols", "UselessHeadgear", "UselessHeadgear", "UselessVests", "OkayWeapons", "ShittyMedical", "SmokeGrenades", "UselessHeadgear", "ShittyPistols", "ShittyWeapons", "ShittyPistols", "UsefulScopes", "GoodVests", "OkayHeadgear", "UselessWeapons", "ShittyVests", "ShittyScopes", "UselessUniforms", "UselessBackpacks", "UselessWeapons", "UselessUniforms", "Binoculars", "ShittyMedical", "UsefulVests", "ShittyPistols", "GoodMedical", "GrenadeTube1Rnd", "ShittyPistols", "GoodWeapons", "WeaponItems", "GoodHeadgear", "UselessHeadgear", "NiceHeadgear", "ShittyUniforms", "ShittyPistols", "ShittyUniforms", "ShittyHandGrenades", "NiceBackpacks", "UsefulWeapons", "GoodHeadgear", "OkayVests", "UselessUniforms", "ShittyUniforms"};
/*
Percental Item Group Spawn Chances of Medical:
ShittyMedical = 3.64%
GoodMedical = 2.73%
NiceMedical = 0.91%
SmokeGrenades = 3.64%
ShittyHandGrenades = 2.73%
GoodHandGrenades = 0.91%
SmokeTube1Rnd = 2.73%
GrenadeTube1Rnd = 1.82%
SmokeTube3Rnd = 0.91%
GrenadeTube3Rnd = 0.91%
WeaponSupressors = 0.91%
WeaponBipods = 0.91%
WeaponItems = 0.91%
UselessWeapons = 3.64%
ShittyWeapons = 2.73%
OkayWeapons = 2.73%
UsefulWeapons = 1.82%
GoodWeapons = 1.82%
NiceWeapons = 0.91%
UselessBackpacks = 2.73%
ShittyBackpacks = 2.73%
OkayBackpacks = 1.82%
UsefulBackpacks = 1.82%
GoodBackpacks = 0.91%
NiceBackpacks = 0.91%
UselessHeadgear = 3.64%
OkayHeadgear = 2.73%
GoodHeadgear = 1.82%
NiceHeadgear = 0.91%
ShittyPistols = 7.27%
GoodPistols = 3.64%
UselessUniforms = 3.64%
ShittyUniforms = 3.64%
OkayUniforms = 1.82%
UselessVests = 3.64%
ShittyVests = 1.82%
OkayVests = 1.82%
UsefulVests = 0.91%
GoodVests = 0.91%
ShittyScopes = 3.64%
OkayScopes = 3.64%
UsefulScopes = 2.73%
GoodScopes = 0.91%
Binoculars = 0.91%
Rangefinders = 0.91%
NightVisionGoggles = 0.91%
*/
Medical[] = {"ShittyScopes", "GoodHeadgear", "UsefulWeapons", "ShittyUniforms", "ShittyScopes", "OkayVests", "ShittyVests", "GrenadeTube3Rnd", "UselessHeadgear", "OkayUniforms", "ShittyPistols", "GoodMedical", "ShittyHandGrenades", "UselessUniforms", "ShittyVests", "UsefulScopes", "GoodMedical", "UsefulWeapons", "SmokeTube3Rnd", "SmokeTube1Rnd", "GrenadeTube1Rnd", "NiceBackpacks", "WeaponItems", "OkayHeadgear", "ShittyHandGrenades", "NiceMedical", "ShittyWeapons", "ShittyUniforms", "GoodMedical", "GoodHandGrenades", "GoodHeadgear", "GoodPistols", "OkayWeapons", "ShittyPistols", "OkayBackpacks", "WeaponSupressors", "OkayScopes", "UselessWeapons", "ShittyPistols", "UselessWeapons", "ShittyPistols", "ShittyScopes", "OkayHeadgear", "UselessHeadgear", "UselessVests", "OkayVests", "UselessVests", "OkayUniforms", "UselessVests", "ShittyBackpacks", "UselessVests", "NightVisionGoggles", "ShittyBackpacks", "GoodPistols", "UselessWeapons", "SmokeGrenades", "SmokeGrenades", "ShittyMedical", "ShittyPistols", "ShittyPistols", "UsefulScopes", "OkayWeapons", "OkayHeadgear", "ShittyUniforms", "OkayScopes", "UsefulBackpacks", "UselessBackpacks", "UsefulScopes", "UselessBackpacks", "NiceHeadgear", "GoodPistols", "ShittyWeapons", "ShittyPistols", "OkayScopes", "ShittyScopes", "OkayWeapons", "WeaponBipods", "UselessBackpacks", "OkayScopes", "ShittyWeapons", "SmokeGrenades", "Binoculars", "GoodBackpacks", "SmokeGrenades", "UselessWeapons", "UselessUniforms", "ShittyMedical", "ShittyUniforms", "UselessUniforms", "UselessUniforms", "UsefulBackpacks", "OkayBackpacks", "GrenadeTube1Rnd", "UsefulVests", "ShittyPistols", "SmokeTube1Rnd", "GoodWeapons", "NiceWeapons", "ShittyHandGrenades", "SmokeTube1Rnd", "ShittyBackpacks", "UselessHeadgear", "ShittyMedical", "GoodScopes", "ShittyMedical", "UselessHeadgear", "Rangefinders", "GoodVests", "GoodPistols", "GoodWeapons"};
/*
Percental Item Group Spawn Chances of Tourist:
ShittyMedical = 3.64%
GoodMedical = 2.73%
NiceMedical = 0.91%
SmokeGrenades = 3.64%
ShittyHandGrenades = 2.73%
GoodHandGrenades = 0.91%
SmokeTube1Rnd = 2.73%
GrenadeTube1Rnd = 1.82%
SmokeTube3Rnd = 0.91%
GrenadeTube3Rnd = 0.91%
WeaponSupressors = 0.91%
WeaponBipods = 0.91%
WeaponItems = 0.91%
UselessWeapons = 3.64%
ShittyWeapons = 2.73%
OkayWeapons = 2.73%
UsefulWeapons = 1.82%
GoodWeapons = 1.82%
NiceWeapons = 0.91%
UselessBackpacks = 2.73%
ShittyBackpacks = 2.73%
OkayBackpacks = 1.82%
UsefulBackpacks = 1.82%
GoodBackpacks = 0.91%
NiceBackpacks = 0.91%
UselessHeadgear = 3.64%
OkayHeadgear = 2.73%
GoodHeadgear = 1.82%
NiceHeadgear = 0.91%
ShittyPistols = 7.27%
GoodPistols = 3.64%
UselessUniforms = 3.64%
ShittyUniforms = 3.64%
OkayUniforms = 1.82%
UselessVests = 3.64%
ShittyVests = 1.82%
OkayVests = 1.82%
UsefulVests = 0.91%
GoodVests = 0.91%
ShittyScopes = 3.64%
OkayScopes = 3.64%
UsefulScopes = 2.73%
GoodScopes = 0.91%
Binoculars = 0.91%
Rangefinders = 0.91%
NightVisionGoggles = 0.91%
*/
Tourist[] = {"GoodMedical", "NiceMedical", "ShittyPistols", "ShittyWeapons", "UselessVests", "GoodScopes", "GoodHandGrenades", "UsefulWeapons", "OkayVests", "ShittyMedical", "GoodPistols", "ShittyPistols", "SmokeTube3Rnd", "UselessWeapons", "ShittyWeapons", "Rangefinders", "UselessUniforms", "SmokeGrenades", "NightVisionGoggles", "ShittyBackpacks", "ShittyScopes", "ShittyMedical", "ShittyHandGrenades", "GrenadeTube1Rnd", "ShittyUniforms", "UselessWeapons", "GoodBackpacks", "UselessHeadgear", "UsefulScopes", "UselessHeadgear", "ShittyHandGrenades", "GrenadeTube3Rnd", "SmokeGrenades", "NiceHeadgear", "ShittyMedical", "OkayWeapons", "OkayWeapons", "ShittyUniforms", "ShittyPistols", "Binoculars", "ShittyUniforms", "UsefulScopes", "ShittyPistols", "UselessBackpacks", "UselessUniforms", "WeaponBipods", "SmokeTube1Rnd", "UselessHeadgear", "WeaponItems", "GoodVests", "ShittyScopes", "GoodHeadgear", "UsefulScopes", "UselessVests", "GoodMedical", "OkayVests", "SmokeGrenades", "ShittyScopes", "UsefulBackpacks", "OkayUniforms", "ShittyScopes", "ShittyMedical", "UsefulBackpacks", "OkayScopes", "GoodMedical", "ShittyPistols", "GrenadeTube1Rnd", "GoodWeapons", "UselessVests", "UselessWeapons", "GoodWeapons", "UsefulWeapons", "UsefulVests", "WeaponSupressors", "UselessBackpacks", "SmokeTube1Rnd", "GoodHeadgear", "UselessHeadgear", "ShittyWeapons", "ShittyBackpacks", "NiceWeapons", "ShittyHandGrenades", "SmokeTube1Rnd", "ShittyPistols", "UselessUniforms", "UselessBackpacks", "OkayHeadgear", "OkayScopes", "GoodPistols", "UselessUniforms", "OkayWeapons", "OkayBackpacks", "OkayUniforms", "OkayBackpacks", "ShittyUniforms", "ShittyVests", "ShittyVests", "UselessWeapons", "ShittyPistols", "OkayHeadgear", "SmokeGrenades", "UselessVests", "OkayScopes", "GoodPistols", "GoodPistols", "ShittyPistols", "OkayHeadgear", "NiceBackpacks", "ShittyBackpacks", "OkayScopes"};
/*
Percental Item Group Spawn Chances of Radiation:
ShittyMedical = 3.64%
GoodMedical = 2.73%
NiceMedical = 0.91%
SmokeGrenades = 3.64%
ShittyHandGrenades = 2.73%
GoodHandGrenades = 0.91%
SmokeTube1Rnd = 2.73%
GrenadeTube1Rnd = 1.82%
SmokeTube3Rnd = 0.91%
GrenadeTube3Rnd = 0.91%
WeaponSupressors = 0.91%
WeaponBipods = 0.91%
WeaponItems = 0.91%
UselessWeapons = 3.64%
ShittyWeapons = 2.73%
OkayWeapons = 2.73%
UsefulWeapons = 1.82%
GoodWeapons = 1.82%
NiceWeapons = 0.91%
UselessBackpacks = 2.73%
ShittyBackpacks = 2.73%
OkayBackpacks = 1.82%
UsefulBackpacks = 1.82%
GoodBackpacks = 0.91%
NiceBackpacks = 0.91%
UselessHeadgear = 3.64%
OkayHeadgear = 2.73%
GoodHeadgear = 1.82%
NiceHeadgear = 0.91%
ShittyPistols = 7.27%
GoodPistols = 3.64%
UselessUniforms = 3.64%
ShittyUniforms = 3.64%
OkayUniforms = 1.82%
UselessVests = 3.64%
ShittyVests = 1.82%
OkayVests = 1.82%
UsefulVests = 0.91%
GoodVests = 0.91%
ShittyScopes = 3.64%
OkayScopes = 3.64%
UsefulScopes = 2.73%
GoodScopes = 0.91%
Binoculars = 0.91%
Rangefinders = 0.91%
NightVisionGoggles = 0.91%
*/
Radiation[] = {"ShittyUniforms", "UselessWeapons", "UselessBackpacks", "ShittyPistols", "ShittyPistols", "OkayBackpacks", "UselessUniforms", "UsefulScopes", "SmokeTube3Rnd", "ShittyHandGrenades", "UsefulScopes", "NiceMedical", "UselessVests", "ShittyScopes", "NightVisionGoggles", "ShittyPistols", "GoodVests", "ShittyMedical", "OkayWeapons", "ShittyScopes", "OkayScopes", "UselessBackpacks", "ShittyBackpacks", "ShittyUniforms", "ShittyHandGrenades", "UsefulVests", "OkayScopes", "OkayVests", "ShittyScopes", "SmokeTube1Rnd", "UselessHeadgear", "UsefulScopes", "OkayHeadgear", "ShittyPistols", "SmokeTube1Rnd", "UsefulBackpacks", "OkayScopes", "UselessUniforms", "WeaponSupressors", "UselessHeadgear", "OkayBackpacks", "GoodWeapons", "ShittyMedical", "SmokeGrenades", "OkayVests", "UselessHeadgear", "GoodMedical", "UselessHeadgear", "ShittyPistols", "SmokeTube1Rnd", "GrenadeTube1Rnd", "GoodScopes", "ShittyPistols", "UselessBackpacks", "ShittyUniforms", "NiceHeadgear", "UselessUniforms", "ShittyUniforms", "SmokeGrenades", "ShittyWeapons", "SmokeGrenades", "OkayWeapons", "ShittyVests", "Binoculars", "UselessWeapons", "GoodHeadgear", "GoodMedical", "GrenadeTube3Rnd", "UsefulWeapons", "OkayHeadgear", "GoodPistols", "ShittyPistols", "GoodPistols", "UselessWeapons", "OkayUniforms", "ShittyWeapons", "ShittyWeapons", "ShittyHandGrenades", "GrenadeTube1Rnd", "OkayHeadgear", "ShittyBackpacks", "OkayScopes", "UselessVests", "ShittyScopes", "WeaponBipods", "UselessUniforms", "UsefulBackpacks", "ShittyMedical", "UselessVests", "GoodMedical", "WeaponItems", "GoodHeadgear", "UselessWeapons", "ShittyMedical", "NiceBackpacks", "GoodBackpacks", "OkayWeapons", "NiceWeapons", "GoodWeapons", "OkayUniforms", "GoodHandGrenades", "ShittyPistols", "UsefulWeapons", "Rangefinders", "UselessVests", "GoodPistols", "SmokeGrenades", "ShittyBackpacks", "ShittyVests", "GoodPistols"};
};
class ItemGroups
{
/*
Percental Item Spawn Chances of UselessWeapons:
Exile_Weapon_CZ550 = 33.33%
Exile_Weapon_M1014 = 33.33%
Exile_Weapon_LeeEnfield = 33.33%
*/
UselessWeapons[] = {"Exile_Weapon_LeeEnfield", "Exile_Weapon_CZ550", "Exile_Weapon_M1014"};
/*
Percental Item Spawn Chances of ShittyWeapons:
hgun_PDW2000_F = 25.00%
SMG_01_F = 25.00%
SMG_02_F = 25.00%
SMG_05_F = 25.00%
*/
ShittyWeapons[] = {"SMG_02_F", "SMG_01_F", "hgun_PDW2000_F", "SMG_05_F"};
/*
Percental Item Spawn Chances of OkayWeapons:
arifle_Mk20_F = 14.29%
arifle_Mk20_GL_F = 14.29%
arifle_Mk20C_F = 14.29%
arifle_SDAR_F = 14.29%
arifle_TRG20_F = 14.29%
arifle_TRG21_F = 14.29%
arifle_TRG21_GL_F = 14.29%
*/
OkayWeapons[] = {"arifle_SDAR_F", "arifle_Mk20_GL_F", "arifle_Mk20_F", "arifle_TRG20_F", "arifle_Mk20C_F", "arifle_TRG21_GL_F", "arifle_TRG21_F"};
/*
Percental Item Spawn Chances of GoodWeapons:
arifle_SPAR_01_blk_F = 16.67%
arifle_SPAR_01_GL_blk_F = 16.67%
arifle_SPAR_01_GL_khk_F = 16.67%
arifle_SPAR_01_GL_snd_F = 16.67%
arifle_SPAR_01_khk_F = 16.67%
arifle_SPAR_01_snd_F = 16.67%
*/
GoodWeapons[] = {"arifle_SPAR_01_GL_snd_F", "arifle_SPAR_01_khk_F", "arifle_SPAR_01_snd_F", "arifle_SPAR_01_GL_khk_F", "arifle_SPAR_01_GL_blk_F", "arifle_SPAR_01_blk_F"};
/*
Percental Item Spawn Chances of UsefulWeapons:
arifle_AKS_F = 7.69%
arifle_Katiba_F = 7.69%
arifle_Katiba_GL_F = 7.69%
arifle_MX_Black_F = 7.69%
arifle_MX_F = 7.69%
arifle_MX_GL_Black_F = 7.69%
arifle_MX_GL_F = 7.69%
arifle_MX_GL_khk_F = 7.69%
arifle_MX_khk_F = 7.69%
arifle_MXC_Black_F = 7.69%
arifle_MXC_F = 7.69%
arifle_MXC_khk_F = 7.69%
Exile_Weapon_AKS_Gold = 7.69%
*/
UsefulWeapons[] = {"arifle_MX_F", "arifle_MX_GL_F", "arifle_Katiba_GL_F", "arifle_AKS_F", "arifle_MX_khk_F", "arifle_MXC_F", "arifle_MX_Black_F", "Exile_Weapon_AKS_Gold", "arifle_MXC_khk_F", "arifle_Katiba_F", "arifle_MXC_Black_F", "arifle_MX_GL_Black_F", "arifle_MX_GL_khk_F"};
/*
Percental Item Spawn Chances of NiceWeapons:
arifle_SPAR_02_blk_F = 4.35%
arifle_SPAR_02_khk_F = 4.35%
arifle_SPAR_02_snd_F = 4.35%
arifle_AK12_F = 4.35%
arifle_AK12_GL_F = 4.35%
arifle_CTAR_blk_F = 4.35%
arifle_CTAR_ghex_F = 4.35%
arifle_CTAR_GL_blk_F = 4.35%
arifle_CTAR_hex_F = 4.35%
arifle_CTARS_blk_F = 4.35%
arifle_CTARS_ghex_F = 4.35%
arifle_CTARS_hex_F = 4.35%
arifle_MXM_Black_F = 4.35%
arifle_MXM_F = 4.35%
arifle_MXM_khk_F = 4.35%
arifle_SPAR_03_blk_F = 4.35%
arifle_SPAR_03_khk_F = 4.35%
arifle_SPAR_03_snd_F = 4.35%
Exile_Weapon_AK107 = 4.35%
Exile_Weapon_AK107_GL = 4.35%
Exile_Weapon_AK47 = 4.35%
Exile_Weapon_AK74 = 4.35%
Exile_Weapon_AK74_GL = 4.35%
*/
NiceWeapons[] = {"Exile_Weapon_AK107_GL", "arifle_MXM_khk_F", "arifle_CTARS_blk_F", "arifle_AK12_F", "arifle_AK12_GL_F", "Exile_Weapon_AK107", "arifle_MXM_Black_F", "arifle_SPAR_02_khk_F", "Exile_Weapon_AK74_GL", "Exile_Weapon_AK47", "Exile_Weapon_AK74", "arifle_CTAR_hex_F", "arifle_MXM_F", "arifle_CTAR_blk_F", "arifle_CTARS_ghex_F", "arifle_SPAR_03_khk_F", "arifle_CTARS_hex_F", "arifle_SPAR_03_snd_F", "arifle_CTAR_GL_blk_F", "arifle_SPAR_03_blk_F", "arifle_SPAR_02_snd_F", "arifle_CTAR_ghex_F", "arifle_SPAR_02_blk_F"};
/*
Percental Item Spawn Chances of EpicWeapons:
arifle_MX_SW_Black_F = 2.63%
arifle_MX_SW_F = 2.63%
Exile_Weapon_DMR = 2.63%
Exile_Weapon_PK = 2.63%
Exile_Weapon_PKP = 2.63%
Exile_Weapon_RPK = 2.63%
Exile_Weapon_SVD = 2.63%
Exile_Weapon_SVDCamo = 2.63%
Exile_Weapon_VSSVintorez = 2.63%
LMG_03_F = 2.63%
LMG_Mk200_F = 2.63%
LMG_Zafir_F = 2.63%
srifle_DMR_01_F = 2.63%
srifle_DMR_02_camo_F = 2.63%
srifle_DMR_02_F = 2.63%
srifle_DMR_02_sniper_F = 2.63%
srifle_DMR_03_F = 2.63%
srifle_DMR_03_khaki_F = 2.63%
srifle_DMR_03_tan_F = 2.63%
srifle_DMR_03_woodland_F = 2.63%
srifle_DMR_04_F = 2.63%
srifle_DMR_04_Tan_F = 2.63%
srifle_DMR_05_blk_F = 2.63%
srifle_DMR_05_hex_F = 2.63%
srifle_DMR_05_tan_F = 2.63%
srifle_DMR_06_camo_F = 2.63%
srifle_DMR_06_olive_F = 2.63%
srifle_DMR_07_blk_F = 2.63%
srifle_DMR_07_ghex_F = 2.63%
srifle_DMR_07_hex_F = 2.63%
srifle_EBR_F = 2.63%
srifle_GM6_F = 2.63%
srifle_GM6_ghex_F = 2.63%
srifle_LRR_F = 2.63%
srifle_LRR_tna_F = 2.63%
arifle_ARX_blk_F = 2.63%
arifle_ARX_ghex_F = 2.63%
arifle_ARX_hex_F = 2.63%
*/
EpicWeapons[] = {"srifle_LRR_tna_F", "srifle_DMR_05_hex_F", "srifle_DMR_01_F", "srifle_DMR_02_camo_F", "srifle_LRR_F", "arifle_MX_SW_F", "Exile_Weapon_SVD", "LMG_Zafir_F", "srifle_DMR_06_olive_F", "Exile_Weapon_RPK", "srifle_DMR_07_ghex_F", "LMG_Mk200_F", "Exile_Weapon_PKP", "srifle_DMR_07_hex_F", "arifle_ARX_blk_F", "srifle_DMR_06_camo_F", "Exile_Weapon_PK", "srifle_DMR_03_khaki_F", "srifle_DMR_04_F", "arifle_MX_SW_Black_F", "Exile_Weapon_VSSVintorez", "srifle_DMR_03_F", "Exile_Weapon_DMR", "srifle_DMR_05_blk_F", "Exile_Weapon_SVDCamo", "srifle_EBR_F", "srifle_DMR_03_woodland_F", "srifle_DMR_05_tan_F", "srifle_DMR_02_F", "srifle_DMR_07_blk_F", "arifle_ARX_hex_F", "arifle_ARX_ghex_F", "srifle_DMR_04_Tan_F", "LMG_03_F", "srifle_GM6_F", "srifle_GM6_ghex_F", "srifle_DMR_03_tan_F", "srifle_DMR_02_sniper_F"};
/*
Percental Item Spawn Chances of ShittyScopes:
optic_Holosight = 20.00%
optic_Holosight_blk_F = 20.00%
optic_Holosight_khk_F = 20.00%
optic_Holosight_smg = 20.00%
optic_Holosight_smg_blk_F = 20.00%
*/
ShittyScopes[] = {"optic_Holosight_blk_F", "optic_Holosight_smg", "optic_Holosight", "optic_Holosight_smg_blk_F", "optic_Holosight_khk_F"};
/*
Percental Item Spawn Chances of OkayScopes:
optic_ACO = 25.00%
optic_ACO_grn = 25.00%
optic_ACO_grn_smg = 25.00%
optic_Aco_smg = 25.00%
*/
OkayScopes[] = {"optic_Aco_smg", "optic_ACO_grn_smg", "optic_ACO_grn", "optic_ACO"};
/*
Percental Item Spawn Chances of UsefulScopes:
optic_Arco = 14.29%
optic_Arco_blk_F = 14.29%
optic_Arco_ghex_F = 14.29%
optic_ERCO_blk_F = 14.29%
optic_ERCO_khk_F = 14.29%
optic_ERCO_snd_F = 14.29%
optic_MRCO = 14.29%
*/
UsefulScopes[] = {"optic_ERCO_khk_F", "optic_Arco_blk_F", "optic_Arco", "optic_Arco_ghex_F", "optic_ERCO_blk_F", "optic_MRCO", "optic_ERCO_snd_F"};
/*
Percental Item Spawn Chances of GoodScopes:
optic_DMS = 25.00%
optic_DMS_ghex_F = 25.00%
optic_Hamr = 25.00%
optic_Hamr_khk_F = 25.00%
*/
GoodScopes[] = {"optic_DMS", "optic_Hamr", "optic_Hamr_khk_F", "optic_DMS_ghex_F"};
/*
Percental Item Spawn Chances of NiceScopes:
optic_AMS = 11.11%
optic_AMS_khk = 11.11%
optic_AMS_snd = 11.11%
optic_KHS_blk = 11.11%
optic_KHS_hex = 11.11%
optic_KHS_old = 11.11%
optic_KHS_tan = 11.11%
optic_SOS = 11.11%
optic_SOS_khk_F = 11.11%
*/
NiceScopes[] = {"optic_AMS", "optic_SOS_khk_F", "optic_AMS_snd", "optic_KHS_tan", "optic_SOS", "optic_KHS_blk", "optic_AMS_khk", "optic_KHS_old", "optic_KHS_hex"};
/*
Percental Item Spawn Chances of WeaponSupressors:
muzzle_snds_58_blk_F = 5.00%
muzzle_snds_58_wdm_F = 5.00%
muzzle_snds_65_TI_blk_F = 5.00%
muzzle_snds_65_TI_ghex_F = 5.00%
muzzle_snds_65_TI_hex_F = 5.00%
muzzle_snds_93mmg = 5.00%
muzzle_snds_93mmg_tan = 5.00%
muzzle_snds_acp = 5.00%
muzzle_snds_B = 5.00%
muzzle_snds_B_khk_F = 5.00%
muzzle_snds_B_snd_F = 5.00%
muzzle_snds_H = 5.00%
muzzle_snds_H_khk_F = 5.00%
muzzle_snds_H_MG_blk_F = 5.00%
muzzle_snds_H_MG_khk_F = 5.00%
muzzle_snds_H_snd_F = 5.00%
muzzle_snds_L = 5.00%
muzzle_snds_M = 5.00%
muzzle_snds_m_khk_F = 5.00%
muzzle_snds_m_snd_F = 5.00%
*/
WeaponSupressors[] = {"muzzle_snds_H_khk_F", "muzzle_snds_B", "muzzle_snds_L", "muzzle_snds_58_blk_F", "muzzle_snds_H", "muzzle_snds_m_snd_F", "muzzle_snds_B_khk_F", "muzzle_snds_acp", "muzzle_snds_m_khk_F", "muzzle_snds_B_snd_F", "muzzle_snds_65_TI_blk_F", "muzzle_snds_H_MG_blk_F", "muzzle_snds_93mmg", "muzzle_snds_65_TI_ghex_F", "muzzle_snds_93mmg_tan", "muzzle_snds_H_MG_khk_F", "muzzle_snds_58_wdm_F", "muzzle_snds_H_snd_F", "muzzle_snds_M", "muzzle_snds_65_TI_hex_F"};
/*
Percental Item Spawn Chances of ZipTies:
Exile_Item_ZipTie = 100.00%
*/
ZipTies[] = {"Exile_Item_ZipTie"};
/*
Percental Item Spawn Chances of WeaponItems:
acc_flashlight = 50.00%
acc_pointer_IR = 50.00%
*/
WeaponItems[] = {"acc_flashlight", "acc_pointer_IR"};
/*
Percental Item Spawn Chances of WeaponBipods:
bipod_01_F_blk = 11.11%
bipod_01_F_khk = 11.11%
bipod_01_F_mtp = 11.11%
bipod_01_F_snd = 11.11%
bipod_02_F_blk = 11.11%
bipod_02_F_hex = 11.11%
bipod_02_F_tan = 11.11%
bipod_03_F_blk = 11.11%
bipod_03_F_oli = 11.11%
*/
WeaponBipods[] = {"bipod_02_F_hex", "bipod_03_F_oli", "bipod_01_F_mtp", "bipod_03_F_blk", "bipod_02_F_blk", "bipod_01_F_snd", "bipod_02_F_tan", "bipod_01_F_blk", "bipod_01_F_khk"};
/*
Percental Item Spawn Chances of UselessVests:
V_BandollierB_blk = 4.55%
V_BandollierB_cbr = 4.55%
V_BandollierB_ghex_F = 4.55%
V_BandollierB_khk = 4.55%
V_BandollierB_oli = 4.55%
V_BandollierB_rgr = 4.55%
V_Chestrig_blk = 4.55%
V_Chestrig_khk = 4.55%
V_Chestrig_oli = 4.55%
V_Chestrig_rgr = 4.55%
V_HarnessO_brn = 4.55%
V_HarnessO_ghex_F = 4.55%
V_HarnessO_gry = 4.55%
V_HarnessOGL_brn = 4.55%
V_HarnessOGL_ghex_F = 4.55%
V_HarnessOGL_gry = 4.55%
V_HarnessOSpec_brn = 4.55%
V_HarnessOSpec_gry = 4.55%
V_Rangemaster_belt = 4.55%
V_TacChestrig_cbr_F = 4.55%
V_TacChestrig_grn_F = 4.55%
V_TacChestrig_oli_F = 4.55%
*/
UselessVests[] = {"V_Chestrig_blk", "V_HarnessO_ghex_F", "V_BandollierB_blk", "V_Chestrig_rgr", "V_HarnessOGL_gry", "V_BandollierB_cbr", "V_HarnessOGL_brn", "V_Chestrig_khk", "V_Rangemaster_belt", "V_BandollierB_oli", "V_TacChestrig_oli_F", "V_HarnessOSpec_gry", "V_HarnessO_brn", "V_Chestrig_oli", "V_TacChestrig_cbr_F", "V_HarnessOGL_ghex_F", "V_BandollierB_rgr", "V_HarnessO_gry", "V_TacChestrig_grn_F", "V_BandollierB_khk", "V_BandollierB_ghex_F", "V_HarnessOSpec_brn"};
/*
Percental Item Spawn Chances of ShittyVests:
V_I_G_resistanceLeader_F = 33.33%
V_TacVest_blk_POLICE = 33.33%
V_TacVest_gen_F = 33.33%
*/
ShittyVests[] = {"V_TacVest_gen_F", "V_I_G_resistanceLeader_F", "V_TacVest_blk_POLICE"};
/*
Percental Item Spawn Chances of OkayVests:
V_PlateCarrier1_blk = 14.29%
V_PlateCarrier1_rgr = 14.29%
V_PlateCarrier1_rgr_noflag_F = 14.29%
V_PlateCarrier1_tna_F = 14.29%
V_PlateCarrierIA1_dgtl = 14.29%
V_PlateCarrierL_CTRG = 14.29%
V_Press_F = 14.29%
*/
OkayVests[] = {"V_PlateCarrierL_CTRG", "V_PlateCarrier1_tna_F", "V_PlateCarrier1_blk", "V_PlateCarrier1_rgr_noflag_F", "V_Press_F", "V_PlateCarrierIA1_dgtl", "V_PlateCarrier1_rgr"};
/*
Percental Item Spawn Chances of UsefulVests:
V_PlateCarrier2_rgr = 16.67%
V_PlateCarrier2_rgr_noflag_F = 16.67%
V_PlateCarrier2_tna_F = 16.67%
V_PlateCarrier3_rgr = 16.67%
V_PlateCarrierH_CTRG = 16.67%
V_PlateCarrierIA2_dgtl = 16.67%
*/
UsefulVests[] = {"V_PlateCarrierH_CTRG", "V_PlateCarrierIA2_dgtl", "V_PlateCarrier2_tna_F", "V_PlateCarrier3_rgr", "V_PlateCarrier2_rgr", "V_PlateCarrier2_rgr_noflag_F"};
/*
Percental Item Spawn Chances of GoodVests:
V_PlateCarrierSpec_blk = 25.00%
V_PlateCarrierSpec_mtp = 25.00%
V_PlateCarrierSpec_rgr = 25.00%
V_PlateCarrierSpec_tna_F = 25.00%
*/
GoodVests[] = {"V_PlateCarrierSpec_mtp", "V_PlateCarrierSpec_tna_F", "V_PlateCarrierSpec_blk", "V_PlateCarrierSpec_rgr"};
/*
Percental Item Spawn Chances of EpicVests:
V_PlateCarrierGL_blk = 16.67%
V_PlateCarrierGL_mtp = 16.67%
V_PlateCarrierGL_rgr = 16.67%
V_PlateCarrierGL_tna_F = 16.67%
V_PlateCarrierIAGL_dgtl = 16.67%
V_PlateCarrierIAGL_oli = 16.67%
*/
EpicVests[] = {"V_PlateCarrierIAGL_oli", "V_PlateCarrierGL_tna_F", "V_PlateCarrierGL_mtp", "V_PlateCarrierGL_rgr", "V_PlateCarrierIAGL_dgtl", "V_PlateCarrierGL_blk"};
/*
Percental Item Spawn Chances of UselessUniforms:
U_C_HunterBody_grn = 4.17%
U_C_Journalist = 4.17%
U_C_Man_casual_1_F = 4.17%
U_C_Man_casual_2_F = 4.17%
U_C_Man_casual_3_F = 4.17%
U_C_Man_casual_4_F = 4.17%
U_C_Man_casual_5_F = 4.17%
U_C_Man_casual_6_F = 4.17%
U_C_man_sport_1_F = 4.17%
U_C_man_sport_2_F = 4.17%
U_C_man_sport_3_F = 4.17%
U_C_Poloshirt_blue = 4.17%
U_C_Poloshirt_burgundy = 4.17%
U_C_Poloshirt_salmon = 4.17%
U_C_Poloshirt_stripped = 4.17%
U_C_Poloshirt_tricolour = 4.17%
U_C_Poor_1 = 4.17%
U_C_Poor_2 = 4.17%
U_C_Poor_shorts_1 = 4.17%
U_C_Scientist = 4.17%
U_NikosAgedBody = 4.17%
U_NikosBody = 4.17%
U_OrestesBody = 4.17%
U_Rangemaster = 4.17%
*/
UselessUniforms[] = {"U_NikosBody", "U_C_Poloshirt_salmon", "U_C_Poloshirt_tricolour", "U_C_HunterBody_grn", "U_C_Poloshirt_burgundy", "U_C_Poor_2", "U_C_Poloshirt_stripped", "U_C_man_sport_3_F", "U_C_Poor_shorts_1", "U_C_Man_casual_5_F", "U_C_Scientist", "U_C_man_sport_2_F", "U_C_Man_casual_6_F", "U_C_Journalist", "U_C_Man_casual_1_F", "U_OrestesBody", "U_C_man_sport_1_F", "U_C_Man_casual_3_F", "U_C_Poor_1", "U_NikosAgedBody", "U_C_Man_casual_2_F", "U_C_Poloshirt_blue", "U_Rangemaster", "U_C_Man_casual_4_F"};
/*
Percental Item Spawn Chances of ShittyUniforms:
U_B_GEN_Commander_F = 4.76%
U_B_GEN_Soldier_F = 4.76%
U_I_C_Soldier_Bandit_1_F = 4.76%
U_I_C_Soldier_Bandit_2_F = 4.76%
U_I_C_Soldier_Bandit_3_F = 4.76%
U_I_C_Soldier_Bandit_4_F = 4.76%
U_I_C_Soldier_Bandit_5_F = 4.76%
U_I_C_Soldier_Camo_F = 4.76%
U_I_C_Soldier_Para_1_F = 4.76%
U_I_C_Soldier_Para_2_F = 4.76%
U_I_C_Soldier_Para_3_F = 4.76%
U_I_C_Soldier_Para_4_F = 4.76%
U_I_C_Soldier_Para_5_F = 4.76%
U_I_G_resistanceLeader_F = 4.76%
U_IG_Guerilla1_1 = 4.76%
U_IG_Guerilla2_1 = 4.76%
U_IG_Guerilla2_2 = 4.76%
U_IG_Guerilla2_3 = 4.76%
U_IG_Guerilla3_1 = 4.76%
U_IG_Guerilla3_2 = 4.76%
U_IG_leader = 4.76%
*/
ShittyUniforms[] = {"U_I_C_Soldier_Camo_F", "U_I_C_Soldier_Para_1_F", "U_IG_Guerilla3_1", "U_I_C_Soldier_Bandit_5_F", "U_I_G_resistanceLeader_F", "U_B_GEN_Commander_F", "U_I_C_Soldier_Bandit_3_F", "U_IG_Guerilla3_2", "U_IG_Guerilla1_1", "U_B_GEN_Soldier_F", "U_IG_Guerilla2_3", "U_I_C_Soldier_Para_2_F", "U_I_C_Soldier_Bandit_2_F", "U_I_C_Soldier_Para_3_F", "U_I_C_Soldier_Bandit_1_F", "U_I_C_Soldier_Bandit_4_F", "U_I_C_Soldier_Para_4_F", "U_I_C_Soldier_Para_5_F", "U_IG_Guerilla2_2", "U_IG_Guerilla2_1", "U_IG_leader"};
/*
Percental Item Spawn Chances of OkayUniforms:
U_B_CombatUniform_mcam = 4.35%
U_B_CombatUniform_mcam_tshirt = 4.35%
U_B_CombatUniform_mcam_vest = 4.35%
U_B_CombatUniform_mcam_worn = 4.35%
U_B_CTRG_1 = 4.35%
U_B_CTRG_2 = 4.35%
U_B_CTRG_3 = 4.35%
U_B_CTRG_Soldier_2_F = 4.35%
U_B_CTRG_Soldier_3_F = 4.35%
U_B_CTRG_Soldier_F = 4.35%
U_B_CTRG_Soldier_urb_1_F = 4.35%
U_B_CTRG_Soldier_urb_2_F = 4.35%
U_B_CTRG_Soldier_urb_3_F = 4.35%
U_B_SpecopsUniform_sgg = 4.35%
U_B_T_Soldier_AR_F = 4.35%
U_B_T_Soldier_SL_F = 4.35%
U_B_Wetsuit = 4.35%
U_I_CombatUniform = 4.35%
U_I_CombatUniform_shortsleeve = 4.35%
U_I_CombatUniform_tshirt = 4.35%
U_I_OfficerUniform = 4.35%
U_I_Wetsuit = 4.35%
U_O_Wetsuit = 4.35%
*/
OkayUniforms[] = {"U_I_CombatUniform_shortsleeve", "U_B_CTRG_Soldier_3_F", "U_B_CTRG_Soldier_urb_3_F", "U_O_Wetsuit", "U_B_T_Soldier_AR_F", "U_B_CombatUniform_mcam_tshirt", "U_I_Wetsuit", "U_I_CombatUniform_tshirt", "U_B_CTRG_1", "U_B_CTRG_3", "U_I_CombatUniform", "U_B_CombatUniform_mcam_worn", "U_B_CTRG_Soldier_2_F", "U_B_SpecopsUniform_sgg", "U_B_CTRG_Soldier_F", "U_B_CTRG_Soldier_urb_2_F", "U_I_OfficerUniform", "U_B_CTRG_Soldier_urb_1_F", "U_B_CTRG_2", "U_B_T_Soldier_SL_F", "U_B_CombatUniform_mcam_vest", "U_B_Wetsuit", "U_B_CombatUniform_mcam"};
/*
Percental Item Spawn Chances of EpicUniforms:
U_B_HeliPilotCoveralls = 7.14%
U_B_PilotCoveralls = 7.14%
U_I_HeliPilotCoveralls = 7.14%
U_I_pilotCoveralls = 7.14%
U_O_CombatUniform_ocamo = 7.14%
U_O_CombatUniform_oucamo = 7.14%
U_O_OfficerUniform_ocamo = 7.14%
U_O_PilotCoveralls = 7.14%
U_O_SpecopsUniform_blk = 7.14%
U_O_SpecopsUniform_ocamo = 7.14%
U_O_T_Officer_F = 7.14%
U_O_T_Soldier_F = 7.14%
U_O_V_Soldier_Viper_F = 7.14%
U_O_V_Soldier_Viper_hex_F = 7.14%
*/
EpicUniforms[] = {"U_O_V_Soldier_Viper_hex_F", "U_I_pilotCoveralls", "U_O_PilotCoveralls", "U_O_T_Officer_F", "U_O_V_Soldier_Viper_F", "U_B_HeliPilotCoveralls", "U_O_SpecopsUniform_blk", "U_O_OfficerUniform_ocamo", "U_B_PilotCoveralls", "U_O_CombatUniform_ocamo", "U_I_HeliPilotCoveralls", "U_O_CombatUniform_oucamo", "U_O_SpecopsUniform_ocamo", "U_O_T_Soldier_F"};
/*
Percental Item Spawn Chances of ShittyHandGrenades:
MiniGrenade = 100.00%
*/
ShittyHandGrenades[] = {"MiniGrenade"};
/*
Percental Item Spawn Chances of GoodHandGrenades:
HandGrenade = 100.00%
*/
GoodHandGrenades[] = {"HandGrenade"};
/*
Percental Item Spawn Chances of SmokeGrenades:
SmokeShell = 14.29%
SmokeShellRed = 14.29%
SmokeShellGreen = 14.29%
SmokeShellYellow = 14.29%
SmokeShellPurple = 14.29%
SmokeShellBlue = 14.29%
SmokeShellOrange = 14.29%
*/
SmokeGrenades[] = {"SmokeShellBlue", "SmokeShellGreen", "SmokeShellPurple", "SmokeShellOrange", "SmokeShell", "SmokeShellYellow", "SmokeShellRed"};
/*
Percental Item Spawn Chances of Rebreathers:
V_RebreatherB = 33.33%
V_RebreatherIR = 33.33%
V_RebreatherIA = 33.33%
*/
Rebreathers[] = {"V_RebreatherIA", "V_RebreatherB", "V_RebreatherIR"};
/*
Percental Item Spawn Chances of Rangefinders:
Rangefinder = 100.00%
*/
Rangefinders[] = {"Rangefinder"};
/*
Percental Item Spawn Chances of ShittyPistols:
hgun_Rook40_F = 16.67%
hgun_P07_F = 16.67%
hgun_P07_khk_F = 16.67%
hgun_Pistol_01_F = 16.67%
Exile_Weapon_Colt1911 = 16.67%
Exile_Weapon_Makarov = 16.67%
*/
ShittyPistols[] = {"Exile_Weapon_Makarov", "Exile_Weapon_Colt1911", "hgun_Pistol_01_F", "hgun_Rook40_F", "hgun_P07_F", "hgun_P07_khk_F"};
/*
Percental Item Spawn Chances of GoodPistols:
hgun_Pistol_heavy_01_F = 20.00%
hgun_Pistol_heavy_02_F = 20.00%
Exile_Weapon_Taurus = 20.00%
Exile_Weapon_TaurusGold = 20.00%
hgun_ACPC2_F = 20.00%
*/
GoodPistols[] = {"Exile_Weapon_TaurusGold", "hgun_ACPC2_F", "Exile_Weapon_Taurus", "hgun_Pistol_heavy_01_F", "hgun_Pistol_heavy_02_F"};
/*
Percental Item Spawn Chances of PistolScopes:
optic_Yorris = 50.00%
optic_MRD = 50.00%
*/
PistolScopes[] = {"optic_MRD", "optic_Yorris"};
/*
Percental Item Spawn Chances of SmokeTube1Rnd:
1Rnd_Smoke_Grenade_shell = 14.29%
1Rnd_SmokeBlue_Grenade_shell = 14.29%
1Rnd_SmokeGreen_Grenade_shell = 14.29%
1Rnd_SmokeOrange_Grenade_shell = 14.29%
1Rnd_SmokePurple_Grenade_shell = 14.29%
1Rnd_SmokeRed_Grenade_shell = 14.29%
1Rnd_SmokeYellow_Grenade_shell = 14.29%
*/
SmokeTube1Rnd[] = {"1Rnd_SmokeYellow_Grenade_shell", "1Rnd_Smoke_Grenade_shell", "1Rnd_SmokeBlue_Grenade_shell", "1Rnd_SmokeRed_Grenade_shell", "1Rnd_SmokeOrange_Grenade_shell", "1Rnd_SmokePurple_Grenade_shell", "1Rnd_SmokeGreen_Grenade_shell"};
/*
Percental Item Spawn Chances of SmokeTube3Rnd:
3Rnd_Smoke_Grenade_shell = 14.29%
3Rnd_SmokeBlue_Grenade_shell = 14.29%
3Rnd_SmokeGreen_Grenade_shell = 14.29%
3Rnd_SmokeOrange_Grenade_shell = 14.29%
3Rnd_SmokePurple_Grenade_shell = 14.29%
3Rnd_SmokeRed_Grenade_shell = 14.29%
3Rnd_SmokeYellow_Grenade_shell = 14.29%
*/
SmokeTube3Rnd[] = {"3Rnd_SmokePurple_Grenade_shell", "3Rnd_SmokeGreen_Grenade_shell", "3Rnd_SmokeBlue_Grenade_shell", "3Rnd_SmokeOrange_Grenade_shell", "3Rnd_SmokeRed_Grenade_shell", "3Rnd_SmokeYellow_Grenade_shell", "3Rnd_Smoke_Grenade_shell"};
/*
Percental Item Spawn Chances of GrenadeTube1Rnd:
1Rnd_HE_Grenade_shell = 100.00%
*/
GrenadeTube1Rnd[] = {"1Rnd_HE_Grenade_shell"};
/*
Percental Item Spawn Chances of GrenadeTube3Rnd:
3Rnd_HE_Grenade_shell = 100.00%
*/
GrenadeTube3Rnd[] = {"3Rnd_HE_Grenade_shell"};
/*
Percental Item Spawn Chances of NightVisionGoggles:
NVGoggles = 20.00%
NVGoggles_tna_F = 20.00%
O_NVGoggles_ghex_F = 20.00%
O_NVGoggles_hex_F = 20.00%
O_NVGoggles_urb_F = 20.00%
*/
NightVisionGoggles[] = {"O_NVGoggles_urb_F", "NVGoggles", "NVGoggles_tna_F", "O_NVGoggles_ghex_F", "O_NVGoggles_hex_F"};
/*
Percental Item Spawn Chances of ShittyMedical:
Exile_Item_Bandage = 100.00%
*/
ShittyMedical[] = {"Exile_Item_Bandage"};
/*
Percental Item Spawn Chances of GoodMedical:
Exile_Item_Vishpirin = 100.00%
*/
GoodMedical[] = {"Exile_Item_Vishpirin"};
/*
Percental Item Spawn Chances of NiceMedical:
Exile_Item_InstaDoc = 100.00%
*/
NiceMedical[] = {"Exile_Item_InstaDoc"};
/*
Percental Item Spawn Chances of UselessHeadgear:
H_Bandanna_camo = 1.32%
H_Bandanna_cbr = 1.32%
H_Bandanna_gry = 1.32%
H_Bandanna_khk = 1.32%
H_Bandanna_khk_hs = 1.32%
H_Bandanna_mcamo = 1.32%
H_Bandanna_sgg = 1.32%
H_Bandanna_surfer = 1.32%
H_Beret_02 = 1.32%
H_Beret_blk = 1.32%
H_Beret_blk_POLICE = 1.32%
H_Beret_brn_SF = 1.32%
H_Beret_Colonel = 1.32%
H_Beret_grn = 1.32%
H_Beret_grn_SF = 1.32%
H_Beret_ocamo = 1.32%
H_Beret_red = 1.32%
H_Booniehat_tna_F = 1.32%
H_Cap_blk = 1.32%
H_Cap_blk_Raven = 1.32%
H_Cap_blk_Syndikat_F = 1.32%
H_Cap_blu = 1.32%
H_Cap_grn = 1.32%
H_Cap_grn_Syndikat_F = 1.32%
H_Cap_headphones = 1.32%
H_Cap_oli = 1.32%
H_Cap_oli_Syndikat_F = 1.32%
H_Cap_press = 1.32%
H_Cap_red = 1.32%
H_Cap_tan = 1.32%
H_Cap_tan_Syndikat_F = 1.32%
H_FakeHeadgear_Syndikat_F = 1.32%
H_Hat_blue = 1.32%
H_Hat_brown = 1.32%
H_Hat_checker = 1.32%
H_Hat_grey = 1.32%
H_Hat_tan = 1.32%
H_MilCap_gen_F = 1.32%
H_MilCap_ghex_F = 1.32%
H_MilCap_tna_F = 1.32%
H_Shemag_khk = 1.32%
H_Shemag_olive = 1.32%
H_Shemag_olive_hs = 1.32%
H_Shemag_tan = 1.32%
H_ShemagOpen_khk = 1.32%
H_ShemagOpen_tan = 1.32%
H_StrawHat = 1.32%
H_StrawHat_dark = 1.32%
H_TurbanO_blk = 1.32%
H_Watchcap_camo = 1.32%
H_Watchcap_sgg = 1.32%
H_BandMask_blk = 1.32%
H_Cap_brn_SPECOPS = 1.32%
H_Cap_khaki_specops_UK = 1.32%
H_Cap_tan_specops_US = 1.32%
H_Hat_camo = 1.32%
H_Watchcap_blk = 1.32%
H_Watchcap_khk = 1.32%
H_Booniehat_dgtl = 1.32%
H_Booniehat_dirty = 1.32%
H_Booniehat_grn = 1.32%
H_Booniehat_indp = 1.32%
H_Booniehat_khk = 1.32%
H_Booniehat_khk_hs = 1.32%
H_Booniehat_mcamo = 1.32%
H_Booniehat_tan = 1.32%
H_BandMask_demon = 1.32%
H_BandMask_khk = 1.32%
H_BandMask_reaper = 1.32%
H_Beret_gen_F = 1.32%
H_MilCap_blue = 1.32%
H_MilCap_dgtl = 1.32%
H_MilCap_mcamo = 1.32%
H_MilCap_ocamo = 1.32%
H_MilCap_oucamo = 1.32%
H_MilCap_rucamo = 1.32%
*/
UselessHeadgear[] = {"H_Watchcap_blk", "H_Beret_ocamo", "H_Watchcap_camo", "H_Shemag_olive", "H_MilCap_oucamo", "H_Hat_blue", "H_MilCap_ocamo", "H_Booniehat_khk", "H_Booniehat_dgtl", "H_FakeHeadgear_Syndikat_F", "H_BandMask_reaper", "H_StrawHat", "H_TurbanO_blk", "H_Bandanna_sgg", "H_Cap_headphones", "H_BandMask_blk", "H_Beret_blk", "H_Cap_oli", "H_Shemag_khk", "H_Beret_02", "H_Booniehat_indp", "H_Watchcap_khk", "H_Bandanna_camo", "H_Bandanna_khk", "H_Bandanna_gry", "H_Beret_blk_POLICE", "H_ShemagOpen_tan", "H_Bandanna_mcamo", "H_Bandanna_cbr", "H_Beret_brn_SF", "H_Bandanna_khk_hs", "H_Beret_gen_F", "H_Booniehat_mcamo", "H_Beret_grn_SF", "H_Hat_tan", "H_BandMask_demon", "H_Beret_Colonel", "H_Cap_tan_Syndikat_F", "H_Shemag_tan", "H_ShemagOpen_khk", "H_Cap_blk_Raven", "H_MilCap_gen_F", "H_Cap_oli_Syndikat_F", "H_Cap_press", "H_Cap_blu", "H_MilCap_rucamo", "H_Cap_blk_Syndikat_F", "H_MilCap_ghex_F", "H_Booniehat_grn", "H_Bandanna_surfer", "H_StrawHat_dark", "H_Beret_grn", "H_Shemag_olive_hs", "H_Cap_tan_specops_US", "H_Beret_red", "H_Hat_camo", "H_Hat_brown", "H_Cap_grn", "H_BandMask_khk", "H_Booniehat_tan", "H_Cap_red", "H_MilCap_tna_F", "H_MilCap_mcamo", "H_Watchcap_sgg", "H_Booniehat_khk_hs", "H_Cap_tan", "H_MilCap_dgtl", "H_Hat_checker", "H_Booniehat_tna_F", "H_Cap_brn_SPECOPS", "H_MilCap_blue", "H_Hat_grey", "H_Booniehat_dirty", "H_Cap_blk", "H_Cap_khaki_specops_UK", "H_Cap_grn_Syndikat_F"};
/*
Percental Item Spawn Chances of OkayHeadgear:
H_Helmet_Skate = 12.50%
H_HelmetB_light_black = 12.50%
H_HelmetB_light_desert = 12.50%
H_HelmetB_light_grass = 12.50%
H_HelmetB_light_sand = 12.50%
H_HelmetB_light_snakeskin = 12.50%
H_HelmetB_Light_tna_F = 12.50%
H_HelmetB_light = 12.50%
*/
OkayHeadgear[] = {"H_HelmetB_light", "H_HelmetB_light_grass", "H_HelmetB_light_black", "H_Helmet_Skate", "H_HelmetB_light_sand", "H_HelmetB_light_desert", "H_HelmetB_Light_tna_F", "H_HelmetB_light_snakeskin"};
/*
Percental Item Spawn Chances of GoodHeadgear:
H_HelmetB_camo = 6.25%
H_PilotHelmetHeli_B = 6.25%
H_PilotHelmetHeli_I = 6.25%
H_PilotHelmetHeli_O = 6.25%
H_HelmetB_black = 6.25%
H_HelmetB_desert = 6.25%
H_HelmetB_grass = 6.25%
H_HelmetB_sand = 6.25%
H_HelmetB_snakeskin = 6.25%
H_HelmetB_tna_F = 6.25%
H_HelmetIA_camo = 6.25%
H_HelmetIA_net = 6.25%
H_HelmetB = 6.25%
H_HelmetB_paint = 6.25%
H_HelmetB_plain_blk = 6.25%
H_HelmetIA = 6.25%
*/
GoodHeadgear[] = {"H_HelmetB", "H_HelmetB_black", "H_HelmetIA_net", "H_PilotHelmetHeli_I", "H_PilotHelmetHeli_B", "H_HelmetB_tna_F", "H_HelmetB_sand", "H_HelmetB_paint", "H_HelmetB_snakeskin", "H_HelmetIA_camo", "H_HelmetIA", "H_PilotHelmetHeli_O", "H_HelmetB_desert", "H_HelmetB_camo", "H_HelmetB_plain_blk", "H_HelmetB_grass"};
/*
Percental Item Spawn Chances of NiceHeadgear:
H_HelmetCrew_B = 14.29%
H_HelmetCrew_I = 14.29%
H_HelmetCrew_O = 14.29%
H_HelmetO_ocamo = 14.29%
H_HelmetO_oucamo = 14.29%
H_HelmetO_ghex_F = 14.29%
H_HelmetCrew_O_ghex_F = 14.29%
*/
NiceHeadgear[] = {"H_HelmetCrew_I", "H_HelmetCrew_O_ghex_F", "H_HelmetCrew_B", "H_HelmetO_ocamo", "H_HelmetO_ghex_F", "H_HelmetO_oucamo", "H_HelmetCrew_O"};
/*
Percental Item Spawn Chances of EpicHeadgear:
H_CrewHelmetHeli_B = 5.56%
H_CrewHelmetHeli_I = 5.56%
H_CrewHelmetHeli_O = 5.56%
H_PilotHelmetFighter_B = 5.56%
H_PilotHelmetFighter_I = 5.56%
H_PilotHelmetFighter_O = 5.56%
H_HelmetSpecO_ghex_F = 5.56%
H_HelmetSpecB = 5.56%
H_HelmetSpecB_blk = 5.56%
H_HelmetSpecB_paint1 = 5.56%
H_HelmetSpecB_paint2 = 5.56%
H_HelmetB_TI_tna_F = 5.56%
H_HelmetSpecO_blk = 5.56%
H_HelmetSpecO_ocamo = 5.56%
H_HelmetB_Enh_tna_F = 5.56%
H_HelmetLeaderO_ocamo = 5.56%
H_HelmetLeaderO_oucamo = 5.56%
H_HelmetLeaderO_ghex_F = 5.56%
*/
EpicHeadgear[] = {"H_HelmetSpecO_blk", "H_HelmetLeaderO_oucamo", "H_HelmetSpecO_ghex_F", "H_CrewHelmetHeli_O", "H_HelmetSpecB", "H_HelmetSpecB_blk", "H_HelmetLeaderO_ghex_F", "H_PilotHelmetFighter_B", "H_HelmetB_TI_tna_F", "H_HelmetSpecB_paint1", "H_HelmetSpecO_ocamo", "H_PilotHelmetFighter_I", "H_HelmetB_Enh_tna_F", "H_CrewHelmetHeli_I", "H_PilotHelmetFighter_O", "H_HelmetSpecB_paint2", "H_HelmetLeaderO_ocamo", "H_CrewHelmetHeli_B"};
/*
Percental Item Spawn Chances of Explosives:
APERSTripMine_Wire_Mag = 100.00%
*/
Explosives[] = {"APERSTripMine_Wire_Mag"};
/*
Percental Item Spawn Chances of Binoculars:
Binocular = 100.00%
*/
Binoculars[] = {"Binocular"};
/*
Percental Item Spawn Chances of UselessBackpacks:
B_HuntingBackpack = 25.00%
B_OutdoorPack_blk = 25.00%
B_OutdoorPack_blu = 25.00%
B_OutdoorPack_tan = 25.00%
*/
UselessBackpacks[] = {"B_HuntingBackpack", "B_OutdoorPack_blk", "B_OutdoorPack_tan", "B_OutdoorPack_blu"};
/*
Percental Item Spawn Chances of ShittyBackpacks:
B_AssaultPack_blk = 12.50%
B_AssaultPack_cbr = 12.50%
B_AssaultPack_dgtl = 12.50%
B_AssaultPack_khk = 12.50%
B_AssaultPack_mcamo = 12.50%
B_AssaultPack_rgr = 12.50%
B_AssaultPack_sgg = 12.50%
B_AssaultPack_tna_F = 12.50%
*/
ShittyBackpacks[] = {"B_AssaultPack_sgg", "B_AssaultPack_mcamo", "B_AssaultPack_tna_F", "B_AssaultPack_dgtl", "B_AssaultPack_khk", "B_AssaultPack_rgr", "B_AssaultPack_blk", "B_AssaultPack_cbr"};
/*
Percental Item Spawn Chances of OkayBackpacks:
B_FieldPack_blk = 20.00%
B_FieldPack_cbr = 20.00%
B_FieldPack_ghex_F = 20.00%
B_FieldPack_ocamo = 20.00%
B_FieldPack_oucamo = 20.00%
*/
OkayBackpacks[] = {"B_FieldPack_oucamo", "B_FieldPack_blk", "B_FieldPack_cbr", "B_FieldPack_ghex_F", "B_FieldPack_ocamo"};
/*
Percental Item Spawn Chances of UsefulBackpacks:
B_ViperLightHarness_blk_F = 20.00%
B_ViperLightHarness_ghex_F = 20.00%
B_ViperLightHarness_hex_F = 20.00%
B_ViperLightHarness_khk_F = 20.00%
B_ViperLightHarness_oli_F = 20.00%
*/
UsefulBackpacks[] = {"B_ViperLightHarness_khk_F", "B_ViperLightHarness_hex_F", "B_ViperLightHarness_blk_F", "B_ViperLightHarness_oli_F", "B_ViperLightHarness_ghex_F"};
/*
Percental Item Spawn Chances of GoodBackpacks:
B_Bergen_blk = 8.33%
B_Bergen_mcamo = 8.33%
B_Bergen_rgr = 8.33%
B_Bergen_sgg = 8.33%
B_Kitbag_cbr = 8.33%
B_Kitbag_mcamo = 8.33%
B_Kitbag_sgg = 8.33%
B_ViperHarness_blk_F = 8.33%
B_ViperHarness_ghex_F = 8.33%
B_ViperHarness_hex_F = 8.33%
B_ViperHarness_khk_F = 8.33%
B_ViperHarness_oli_F = 8.33%
*/
GoodBackpacks[] = {"B_Kitbag_sgg", "B_Kitbag_mcamo", "B_Bergen_sgg", "B_Bergen_rgr", "B_ViperHarness_hex_F", "B_ViperHarness_khk_F", "B_ViperHarness_blk_F", "B_ViperHarness_ghex_F", "B_Bergen_mcamo", "B_ViperHarness_oli_F", "B_Kitbag_cbr", "B_Bergen_blk"};
/*
Percental Item Spawn Chances of NiceBackpacks:
B_Carryall_cbr = 14.29%
B_Carryall_ghex_F = 14.29%
B_Carryall_khk = 14.29%
B_Carryall_mcamo = 14.29%
B_Carryall_ocamo = 14.29%
B_Carryall_oli = 14.29%
B_Carryall_oucamo = 14.29%
*/
NiceBackpacks[] = {"B_Carryall_mcamo", "B_Carryall_ocamo", "B_Carryall_oucamo", "B_Carryall_ghex_F", "B_Carryall_khk", "B_Carryall_cbr", "B_Carryall_oli"};
/*
Percental Item Spawn Chances of EpicBackpacks:
B_Bergen_dgtl_F = 25.00%
B_Bergen_hex_F = 25.00%
B_Bergen_mcamo_F = 25.00%
B_Bergen_tna_F = 25.00%
*/
EpicBackpacks[] = {"B_Bergen_tna_F", "B_Bergen_mcamo_F", "B_Bergen_hex_F", "B_Bergen_dgtl_F"};
};
};
class CfgExileLootServer
{
class LootTables
{
/*
Percental Item Group Spawn Chances of CivillianLowerClass:
Restraints = 0.53%
PistolAttachments = 1.60%
ShotgunAmmo = 1.60%
SMGAmmo = 1.60%
SMGAttachments = 1.60%
Shotguns = 2.13%
SMG = 2.13%
CivilianVests = 2.66%
PistolAmmo = 2.66%
Pistols = 4.26%
Chemlights = 5.32%
CivilianItems = 5.32%
Drinks = 5.32%
RoadFlares = 5.32%
CivilianBackpacks = 5.85%
CivilianClothing = 10.64%
CivilianHeadgear = 10.64%
Food = 14.89%
Trash = 15.96%
*/
CivillianLowerClass[] = {"Trash", "SMGAttachments", "CivilianItems", "CivilianItems", "Pistols", "Trash", "CivilianItems", "Food", "Food", "Trash", "CivilianBackpacks", "Pistols", "Drinks", "Food", "Pistols", "RoadFlares", "Trash", "Trash", "CivilianClothing", "Food", "CivilianClothing", "PistolAttachments", "CivilianClothing", "CivilianClothing", "PistolAmmo", "CivilianClothing", "CivilianBackpacks", "Chemlights", "Trash", "Trash", "Chemlights", "CivilianHeadgear", "CivilianBackpacks", "Food", "Chemlights", "CivilianHeadgear", "Food", "Drinks", "CivilianVests", "ShotgunAmmo", "CivilianClothing", "CivilianVests", "CivilianClothing", "Drinks", "Pistols", "ShotgunAmmo", "RoadFlares", "SMG", "CivilianClothing", "CivilianHeadgear", "CivilianHeadgear", "Drinks", "Trash", "CivilianBackpacks", "Shotguns", "SMGAmmo", "Trash", "Trash", "Trash", "RoadFlares", "Food", "CivilianHeadgear", "Food", "Trash", "CivilianBackpacks", "Food", "Food", "CivilianHeadgear", "CivilianClothing", "CivilianHeadgear", "CivilianItems", "CivilianVests", "CivilianHeadgear", "PistolAttachments", "Chemlights", "Restraints", "CivilianClothing", "SMGAttachments", "CivilianVests", "Pistols", "Trash", "Food", "Food", "SMG", "CivilianHeadgear", "CivilianItems", "Drinks", "CivilianClothing", "PistolAmmo", "Trash", "CivilianClothing", "CivilianHeadgear", "SMGAmmo", "CivilianVests", "Trash", "CivilianHeadgear", "Trash", "CivilianItems", "Food", "Shotguns", "CivilianItems", "PistolAmmo", "CivilianHeadgear", "Drinks", "SMG", "ShotgunAmmo", "CivilianBackpacks", "RoadFlares", "Pistols", "RoadFlares", "PistolAttachments", "CivilianBackpacks", "Trash", "CivilianClothing", "SMG", "RoadFlares", "Trash", "Pistols", "Food", "PistolAmmo", "Food", "CivilianItems", "SMGAttachments", "Chemlights", "RoadFlares", "Trash", "Food", "Chemlights", "CivilianBackpacks", "CivilianHeadgear", "CivilianBackpacks", "Pistols", "CivilianHeadgear", "Trash", "Chemlights", "SMGAmmo", "CivilianHeadgear", "Trash", "Trash", "Shotguns", "CivilianHeadgear", "Chemlights", "RoadFlares", "Drinks", "Trash", "Trash", "Food", "Food", "Trash", "CivilianHeadgear", "Drinks", "Chemlights", "CivilianHeadgear", "CivilianClothing", "Food", "Food", "CivilianItems", "RoadFlares", "CivilianClothing", "CivilianClothing", "PistolAmmo", "Trash", "Food", "Food", "Shotguns", "CivilianItems", "Food", "CivilianClothing", "Drinks", "Food", "CivilianBackpacks", "RoadFlares", "CivilianClothing", "Trash", "Trash", "CivilianClothing", "Drinks", "CivilianBackpacks", "Food", "Chemlights", "Trash", "CivilianClothing", "Trash", "CivilianHeadgear", "Food", "Food", "CivilianHeadgear", "Food"};
/*
Percental Item Group Spawn Chances of CivillianUpperClass:
Restraints = 0.51%
PistolAttachments = 1.52%
RifleAmmo = 1.52%
RifleAttachments = 1.52%
Rifles = 1.52%
ShotgunAmmo = 1.52%
SMGAmmo = 1.52%
SMGAttachments = 1.52%
Shotguns = 2.03%
SMG = 2.03%
CivilianVests = 2.54%
PistolAmmo = 2.54%
Pistols = 4.06%
Chemlights = 5.08%
CivilianItems = 5.08%
Drinks = 5.08%
RoadFlares = 5.08%
CivilianBackpacks = 5.58%
CivilianClothing = 10.15%
CivilianHeadgear = 10.15%
Food = 14.21%
Trash = 15.23%
*/
CivillianUpperClass[] = {"Food", "Trash", "Chemlights", "RoadFlares", "Food", "Food", "CivilianClothing", "Shotguns", "CivilianItems", "CivilianHeadgear", "CivilianHeadgear", "RifleAttachments", "Food", "Trash", "CivilianBackpacks", "Trash", "CivilianHeadgear", "CivilianClothing", "Food", "RifleAttachments", "Trash", "RifleAmmo", "CivilianClothing", "CivilianHeadgear", "Trash", "CivilianHeadgear", "CivilianVests", "Trash", "CivilianBackpacks", "RifleAttachments", "Pistols", "RifleAmmo", "CivilianHeadgear", "Trash", "CivilianHeadgear", "PistolAmmo", "SMG", "CivilianHeadgear", "Drinks", "Pistols", "Trash", "Trash", "Food", "CivilianClothing", "SMGAmmo", "RoadFlares", "Food", "CivilianClothing", "CivilianClothing", "Chemlights", "SMGAmmo", "Chemlights", "CivilianVests", "CivilianClothing", "Trash", "Trash", "RifleAmmo", "Drinks", "CivilianClothing", "CivilianHeadgear", "Trash", "Chemlights", "Trash", "CivilianClothing", "Food", "Food", "Food", "Trash", "Chemlights", "Trash", "Food", "PistolAttachments", "Chemlights", "Trash", "CivilianItems", "CivilianClothing", "Drinks", "Trash", "Chemlights", "CivilianItems", "CivilianHeadgear", "Trash", "CivilianItems", "Food", "CivilianBackpacks", "Pistols", "Trash", "Trash", "CivilianItems", "Shotguns", "Trash", "CivilianHeadgear", "RoadFlares", "CivilianHeadgear", "Food", "Food", "RoadFlares", "PistolAmmo", "Trash", "Rifles", "Drinks", "Food", "Chemlights", "Drinks", "CivilianClothing", "SMG", "Food", "CivilianBackpacks", "CivilianVests", "Trash", "PistolAttachments", "CivilianItems", "CivilianBackpacks", "CivilianItems", "CivilianClothing", "CivilianHeadgear", "CivilianClothing", "Food", "CivilianClothing", "SMGAmmo", "Rifles", "CivilianVests", "Rifles", "Trash", "Food", "CivilianHeadgear", "Trash", "CivilianHeadgear", "Food", "ShotgunAmmo", "Drinks", "CivilianHeadgear", "CivilianClothing", "Drinks", "Chemlights", "CivilianHeadgear", "Food", "CivilianClothing", "CivilianBackpacks", "CivilianHeadgear", "CivilianBackpacks", "PistolAmmo", "Shotguns", "CivilianClothing", "RoadFlares", "SMGAttachments", "CivilianItems", "CivilianVests", "SMGAttachments", "Food", "Pistols", "Drinks", "Pistols", "Food", "Food", "ShotgunAmmo", "CivilianItems", "Shotguns", "Drinks", "CivilianClothing", "SMG", "Food", "Trash", "RoadFlares", "Trash", "CivilianBackpacks", "CivilianClothing", "Pistols", "CivilianHeadgear", "RoadFlares", "CivilianBackpacks", "Pistols", "Food", "Chemlights", "SMGAttachments", "CivilianHeadgear", "CivilianItems", "Trash", "Drinks", "SMG", "Trash", "RoadFlares", "Food", "Trash", "CivilianClothing", "ShotgunAmmo", "CivilianBackpacks", "RoadFlares", "Food", "PistolAmmo", "RoadFlares", "Pistols", "Restraints", "CivilianBackpacks", "PistolAmmo", "Food", "PistolAttachments"};
/*
Percental Item Group Spawn Chances of Shop:
CivilianClothing = 0.80%
CivilianVests = 0.80%
PistolAttachments = 0.80%
ShotgunAmmo = 0.80%
SMGAmmo = 0.80%
SMGAttachments = 0.80%
PistolAmmo = 1.60%
CivilianHeadgear = 2.40%
IndustrialItems = 2.40%
MedicalItems = 2.40%
Restraints = 2.40%
Shotguns = 3.20%
SmokeGrenades = 3.20%
Chemlights = 4.00%
CivilianBackpacks = 4.00%
RoadFlares = 4.00%
SMG = 4.00%
CivilianItems = 5.60%
Pistols = 8.00%
Drinks = 12.00%
Food = 12.00%
Trash = 24.00%
*/
Shop[] = {"CivilianVests", "CivilianClothing", "PistolAttachments", "SMGAttachments", "CivilianBackpacks", "RoadFlares", "CivilianHeadgear", "Shotguns", "Pistols", "Food", "Food", "Restraints", "Drinks", "PistolAmmo", "ShotgunAmmo", "Pistols", "PistolAmmo", "Trash", "Food", "CivilianItems", "CivilianBackpacks", "Trash", "Trash", "Trash", "Chemlights", "Drinks", "CivilianItems", "Food", "SMG", "CivilianItems", "Trash", "Trash", "Drinks", "Pistols", "Drinks", "Food", "CivilianItems", "Drinks", "CivilianItems", "Trash", "Trash", "RoadFlares", "Trash", "Trash", "CivilianBackpacks", "Shotguns", "Chemlights", "Trash", "SMG", "Chemlights", "Trash", "Shotguns", "RoadFlares", "Trash", "Pistols", "Food", "MedicalItems", "Trash", "Food", "Drinks", "Pistols", "Trash", "RoadFlares", "Food", "Pistols", "SmokeGrenades", "Drinks", "Trash", "RoadFlares", "Trash", "Trash", "CivilianItems", "Trash", "Food", "Chemlights", "CivilianBackpacks", "IndustrialItems", "Drinks", "Drinks", "Food", "Drinks", "Trash", "IndustrialItems", "Drinks", "Drinks", "Food", "Drinks", "Shotguns", "Trash", "Food", "Food", "SMG", "MedicalItems", "Trash", "Pistols", "Food", "Trash", "SMG", "Trash", "Drinks", "Drinks", "Trash", "CivilianBackpacks", "CivilianHeadgear", "Pistols", "Restraints", "MedicalItems", "Pistols", "Trash", "Trash", "SmokeGrenades", "SmokeGrenades", "Trash", "SMG", "Food", "Pistols", "SmokeGrenades", "CivilianHeadgear", "Trash", "SMGAmmo", "Restraints", "CivilianItems", "IndustrialItems", "Trash", "Chemlights"};
/*
Percental Item Group Spawn Chances of Industrial:
Restraints = 4.35%
RoadFlares = 13.04%
Vehicle = 21.74%
Trash = 26.09%
IndustrialItems = 34.78%
*/
Industrial[] = {"Trash", "Trash", "Vehicle", "IndustrialItems", "IndustrialItems", "RoadFlares", "Trash", "Trash", "IndustrialItems", "Vehicle", "IndustrialItems", "RoadFlares", "IndustrialItems", "IndustrialItems", "Trash", "Restraints", "Vehicle", "IndustrialItems", "Trash", "Vehicle", "Vehicle", "IndustrialItems", "RoadFlares"};
/*
Percental Item Group Spawn Chances of Factories:
Electronics = 10.00%
Trash = 40.00%
IndustrialItems = 50.00%
*/
Factories[] = {"IndustrialItems", "Trash", "Trash", "IndustrialItems", "IndustrialItems", "Trash", "Electronics", "IndustrialItems", "Trash", "IndustrialItems"};
/*
Percental Item Group Spawn Chances of VehicleService:
Restraints = 4.35%
RoadFlares = 13.04%
IndustrialItems = 21.74%
Trash = 26.09%
Vehicle = 34.78%
*/
VehicleService[] = {"Trash", "Vehicle", "Vehicle", "IndustrialItems", "IndustrialItems", "Trash", "RoadFlares", "Vehicle", "Trash", "Trash", "Vehicle", "Vehicle", "Vehicle", "Restraints", "IndustrialItems", "IndustrialItems", "RoadFlares", "Trash", "Vehicle", "Vehicle", "RoadFlares", "Trash", "IndustrialItems"};
/*
Percental Item Group Spawn Chances of Military:
DLCGhillies = 0.50%
Ghillies = 0.50%
Rebreathers = 0.50%
Bipods = 0.99%
DLCAmmo = 0.99%
DLCOptics = 0.99%
DLCSupressor = 0.99%
LMGAmmo = 0.99%
MedicalItems = 0.99%
Restraints = 0.99%
SniperAmmo = 0.99%
SniperAttachments = 0.99%
DLCRifles = 1.49%
DLCVests = 1.49%
GuerillaHeadgear = 1.49%
GuerillaVests = 1.49%
HandGrenades = 1.49%
HEGrenades = 1.49%
MilitaryBackpacks = 1.49%
MilitaryHeadgear = 1.49%
MilitaryVests = 1.49%
RifleAmmo = 1.49%
RifleAttachments = 1.49%
SmokeGrenades = 1.49%
Snipers = 1.49%
UGLFlares = 1.49%
UGLSmokes = 1.49%
CivilianItems = 1.98%
GuerillaBackpacks = 1.98%
GuerillaItems = 1.98%
LMG = 1.98%
Explosives = 2.48%
GuerillaClothing = 2.48%
MilitaryClothing = 2.48%
Rifles = 2.48%
Trash = 49.50%
*/
Military[] = {"Trash", "Trash", "MilitaryClothing", "Trash", "LMGAmmo", "Trash", "DLCOptics", "MedicalItems", "Trash", "MilitaryHeadgear", "Trash", "Explosives", "Trash", "Restraints", "Trash", "Ghillies", "Trash", "Trash", "Trash", "Trash", "Trash", "Trash", "Trash", "RifleAmmo", "Trash", "MilitaryVests", "Trash", "Trash", "Trash", "DLCGhillies", "GuerillaClothing", "Trash", "Trash", "GuerillaClothing", "GuerillaClothing", "Trash", "Trash", "Trash", "Trash", "LMG", "DLCVests", "Trash", "Explosives", "Trash", "Trash", "Bipods", "Trash", "Explosives", "Trash", "Trash", "MilitaryClothing", "DLCRifles", "Trash", "SmokeGrenades", "Trash", "Trash", "Trash", "Trash", "MilitaryVests", "Trash", "DLCAmmo", "MilitaryClothing", "GuerillaItems", "Snipers", "HandGrenades", "Trash", "Trash", "HandGrenades", "DLCVests", "MilitaryVests", "GuerillaBackpacks", "HEGrenades", "RifleAttachments", "Trash", "Trash", "MilitaryHeadgear", "Trash", "Trash", "Trash", "Trash", "UGLFlares", "Rifles", "Trash", "SniperAttachments", "Trash", "Rifles", "Trash", "Trash", "SniperAmmo", "Trash", "RifleAttachments", "GuerillaVests", "UGLFlares", "LMG", "HEGrenades", "Trash", "RifleAmmo", "Trash", "Trash", "DLCRifles", "Trash", "SniperAmmo", "Rifles", "GuerillaHeadgear", "MilitaryClothing", "Trash", "MedicalItems", "UGLFlares", "Rifles", "Trash", "GuerillaVests", "Trash", "UGLSmokes", "Trash", "RifleAmmo", "Snipers", "Trash", "DLCVests", "Trash", "LMGAmmo", "Restraints", "Trash", "Explosives", "Trash", "Trash", "LMG", "RifleAttachments", "Trash", "MilitaryBackpacks", "Trash", "CivilianItems", "HandGrenades", "DLCRifles", "Trash", "Trash", "Trash", "Trash", "GuerillaHeadgear", "Trash", "MilitaryBackpacks", "Trash", "Trash", "Trash", "Trash", "GuerillaVests", "GuerillaBackpacks", "Trash", "DLCSupressor", "Trash", "Trash", "Snipers", "DLCAmmo", "Trash", "Trash", "CivilianItems", "SmokeGrenades", "UGLSmokes", "Trash", "GuerillaItems", "Trash", "Trash", "Trash", "Trash", "Trash", "Trash", "Explosives", "MilitaryBackpacks", "MilitaryClothing", "GuerillaClothing", "GuerillaHeadgear", "HEGrenades", "GuerillaClothing", "MilitaryHeadgear", "DLCOptics", "Trash", "Rifles", "LMG", "SniperAttachments", "DLCSupressor", "GuerillaBackpacks", "Trash", "Trash", "Trash", "Trash", "CivilianItems", "CivilianItems", "Trash", "GuerillaItems", "Trash", "GuerillaBackpacks", "GuerillaItems", "Trash", "Trash", "Trash", "UGLSmokes", "Trash", "Trash", "Bipods", "Rebreathers", "SmokeGrenades", "Trash", "Trash"};
/*
Percental Item Group Spawn Chances of Medical:
Trash = 30.00%
MedicalItems = 70.00%
*/
Medical[] = {"MedicalItems", "MedicalItems", "Trash", "MedicalItems", "MedicalItems", "Trash", "MedicalItems", "MedicalItems", "Trash", "MedicalItems"};
/*
Percental Item Group Spawn Chances of Tourist:
DLCAmmo = 2.22%
DLCOptics = 2.22%
DLCSupressor = 2.22%
SniperAmmo = 2.22%
SniperAttachments = 2.22%
CivilianItems = 4.44%
Explosives = 4.44%
HandGrenades = 4.44%
MedicalItems = 4.44%
Restraints = 4.44%
DLCGhillies = 6.67%
Ghillies = 6.67%
MilitaryBackpacks = 8.89%
MilitaryHeadgear = 8.89%
DLCRifles = 17.78%
Snipers = 17.78%
*/
Tourist[] = {"MedicalItems", "Ghillies", "DLCRifles", "Snipers", "CivilianItems", "MilitaryHeadgear", "Explosives", "Snipers", "MilitaryHeadgear", "HandGrenades", "MilitaryHeadgear", "DLCSupressor", "Explosives", "Snipers", "Snipers", "DLCGhillies", "SniperAttachments", "DLCAmmo", "Restraints", "DLCRifles", "DLCOptics", "MilitaryBackpacks", "DLCRifles", "Snipers", "DLCRifles", "MedicalItems", "Ghillies", "DLCRifles", "MilitaryBackpacks", "DLCGhillies", "Restraints", "Ghillies", "MilitaryHeadgear", "DLCRifles", "DLCGhillies", "Snipers", "DLCRifles", "MilitaryBackpacks", "Snipers", "SniperAmmo", "Snipers", "DLCRifles", "CivilianItems", "MilitaryBackpacks", "HandGrenades"};
/*
Percental Item Group Spawn Chances of Radiation:
DLCAmmo = 2.27%
DLCOptics = 2.27%
DLCSupressor = 2.27%
SniperAmmo = 2.27%
SniperAttachments = 2.27%
EpicWeapons = 4.55%
HandGrenades = 4.55%
MedicalItems = 4.55%
Restraints = 4.55%
DLCGhillies = 6.82%
Ghillies = 6.82%
Explosives = 11.36%
MilitaryBackpacks = 11.36%
MilitaryHeadgear = 11.36%
DLCRifles = 11.36%
Snipers = 11.36%
*/
Radiation[] = {"SniperAmmo", "DLCRifles", "Snipers", "DLCRifles", "DLCGhillies", "Snipers", "DLCRifles", "SniperAttachments", "MilitaryBackpacks", "MilitaryHeadgear", "Explosives", "MilitaryHeadgear", "Explosives", "DLCRifles", "DLCOptics", "Explosives", "Snipers", "MilitaryHeadgear", "MilitaryBackpacks", "DLCRifles", "Restraints", "Ghillies", "MilitaryHeadgear", "DLCAmmo", "Explosives", "MilitaryBackpacks", "Snipers", "HandGrenades", "Snipers", "MilitaryBackpacks", "MedicalItems", "Ghillies", "DLCGhillies", "MilitaryBackpacks", "MedicalItems", "Restraints", "DLCGhillies", "Ghillies", "HandGrenades", "DLCSupressor", "Explosives", "EpicWeapons", "MilitaryHeadgear", "EpicWeapons"};
};
class ItemGroups
{
/*
Percental Item Spawn Chances of Food:
Exile_Item_CookingPot = 2.08%
Exile_Item_CanOpener = 3.47%
Exile_Item_Matches = 3.47%
Exile_Item_EMRE = 2.08%
Exile_Item_GloriousKnakworst = 4.17%
Exile_Item_Surstromming = 4.86%
Exile_Item_SausageGravy = 4.86%
Exile_Item_ChristmasTinner = 4.86%
Exile_Item_MacasCheese = 4.86%
Exile_Item_BBQSandwich = 4.86%
Exile_Item_CatFood = 4.86%
Exile_Item_Dogfood = 4.86%
Exile_Item_BeefParts = 4.86%
Exile_Item_Cheathas = 4.86%
Exile_Item_DsNuts = 4.86%
Exile_Item_Noodles = 4.86%
Exile_Item_CockONut = 5.56%
Exile_Item_SeedAstics = 5.56%
Exile_Item_Raisins = 6.25%
Exile_Item_Moobar = 6.25%
Exile_Item_InstantCoffee = 7.64%
*/
Food[] = {"Exile_Item_ChristmasTinner", "Exile_Item_Noodles", "Exile_Item_Raisins", "Exile_Item_BBQSandwich", "Exile_Item_BeefParts", "Exile_Item_Raisins", "Exile_Item_Surstromming", "Exile_Item_Surstromming", "Exile_Item_CatFood", "Exile_Item_Cheathas", "Exile_Item_Matches", "Exile_Item_GloriousKnakworst", "Exile_Item_Matches", "Exile_Item_CanOpener", "Exile_Item_GloriousKnakworst", "Exile_Item_BBQSandwich", "Exile_Item_Moobar", "Exile_Item_Matches", "Exile_Item_Moobar", "Exile_Item_Raisins", "Exile_Item_BBQSandwich", "Exile_Item_Cheathas", "Exile_Item_CatFood", "Exile_Item_Cheathas", "Exile_Item_Matches", "Exile_Item_MacasCheese", "Exile_Item_Cheathas", "Exile_Item_Surstromming", "Exile_Item_Dogfood", "Exile_Item_CatFood", "Exile_Item_CanOpener", "Exile_Item_CockONut", "Exile_Item_InstantCoffee", "Exile_Item_CockONut", "Exile_Item_ChristmasTinner", "Exile_Item_Matches", "Exile_Item_SausageGravy", "Exile_Item_Moobar", "Exile_Item_BeefParts", "Exile_Item_CockONut", "Exile_Item_SausageGravy", "Exile_Item_InstantCoffee", "Exile_Item_DsNuts", "Exile_Item_Raisins", "Exile_Item_BeefParts", "Exile_Item_InstantCoffee", "Exile_Item_BBQSandwich", "Exile_Item_DsNuts", "Exile_Item_Noodles", "Exile_Item_SeedAstics", "Exile_Item_GloriousKnakworst", "Exile_Item_CanOpener", "Exile_Item_CookingPot", "Exile_Item_CookingPot", "Exile_Item_ChristmasTinner", "Exile_Item_Cheathas", "Exile_Item_MacasCheese", "Exile_Item_CatFood", "Exile_Item_InstantCoffee", "Exile_Item_Noodles", "Exile_Item_Noodles", "Exile_Item_Moobar", "Exile_Item_CanOpener", "Exile_Item_MacasCheese", "Exile_Item_Moobar", "Exile_Item_CatFood", "Exile_Item_DsNuts", "Exile_Item_Dogfood", "Exile_Item_CockONut", "Exile_Item_InstantCoffee", "Exile_Item_Noodles", "Exile_Item_BeefParts", "Exile_Item_DsNuts", "Exile_Item_MacasCheese", "Exile_Item_GloriousKnakworst", "Exile_Item_ChristmasTinner", "Exile_Item_BeefParts", "Exile_Item_GloriousKnakworst", "Exile_Item_SeedAstics", "Exile_Item_Moobar", "Exile_Item_Moobar", "Exile_Item_SausageGravy", "Exile_Item_BBQSandwich", "Exile_Item_EMRE", "Exile_Item_SeedAstics", "Exile_Item_Moobar", "Exile_Item_EMRE", "Exile_Item_SeedAstics", "Exile_Item_CatFood", "Exile_Item_SeedAstics", "Exile_Item_Raisins", "Exile_Item_SeedAstics", "Exile_Item_Surstromming", "Exile_Item_SausageGravy", "Exile_Item_MacasCheese", "Exile_Item_Moobar", "Exile_Item_SeedAstics", "Exile_Item_InstantCoffee", "Exile_Item_DsNuts", "Exile_Item_ChristmasTinner", "Exile_Item_Surstromming", "Exile_Item_InstantCoffee", "Exile_Item_CockONut", "Exile_Item_Dogfood", "Exile_Item_Dogfood", "Exile_Item_BBQSandwich", "Exile_Item_CockONut", "Exile_Item_Surstromming", "Exile_Item_SausageGravy", "Exile_Item_MacasCheese", "Exile_Item_Raisins", "Exile_Item_DsNuts", "Exile_Item_ChristmasTinner", "Exile_Item_Surstromming", "Exile_Item_EMRE", "Exile_Item_Raisins", "Exile_Item_Cheathas", "Exile_Item_InstantCoffee", "Exile_Item_Cheathas", "Exile_Item_Dogfood", "Exile_Item_SausageGravy", "Exile_Item_CanOpener", "Exile_Item_DsNuts", "Exile_Item_SausageGravy", "Exile_Item_ChristmasTinner", "Exile_Item_GloriousKnakworst", "Exile_Item_InstantCoffee", "Exile_Item_BeefParts", "Exile_Item_CockONut", "Exile_Item_InstantCoffee", "Exile_Item_Raisins", "Exile_Item_Noodles", "Exile_Item_CookingPot", "Exile_Item_CockONut", "Exile_Item_BeefParts", "Exile_Item_SeedAstics", "Exile_Item_BBQSandwich", "Exile_Item_InstantCoffee", "Exile_Item_Noodles", "Exile_Item_Raisins", "Exile_Item_Dogfood", "Exile_Item_Dogfood", "Exile_Item_MacasCheese", "Exile_Item_CatFood"};
/*
Percental Item Spawn Chances of Drinks:
Exile_Item_Beer = 7.14%
Exile_Item_EnergyDrink = 7.14%
Exile_Item_PlasticBottleFreshWater = 7.14%
Exile_Item_PowerDrink = 7.14%
Exile_Item_MountainDupe = 14.29%
Exile_Item_ChocolateMilk = 21.43%
Exile_Item_PlasticBottleDirtyWater = 35.71%
*/
Drinks[] = {"Exile_Item_MountainDupe", "Exile_Item_PlasticBottleDirtyWater", "Exile_Item_ChocolateMilk", "Exile_Item_EnergyDrink", "Exile_Item_PlasticBottleDirtyWater", "Exile_Item_PlasticBottleFreshWater", "Exile_Item_Beer", "Exile_Item_PowerDrink", "Exile_Item_PlasticBottleDirtyWater", "Exile_Item_PlasticBottleDirtyWater", "Exile_Item_ChocolateMilk", "Exile_Item_ChocolateMilk", "Exile_Item_PlasticBottleDirtyWater", "Exile_Item_MountainDupe"};
/*
Percental Item Spawn Chances of Pistols:
Exile_Weapon_Colt1911 = 5.88%
Exile_Weapon_Makarov = 5.88%
Exile_Weapon_Taurus = 5.88%
Exile_Weapon_TaurusGold = 5.88%
hgun_P07_khk_F = 5.88%
hgun_Pistol_01_F = 5.88%
hgun_Pistol_heavy_01_F = 5.88%
hgun_Pistol_heavy_02_F = 5.88%
hgun_Pistol_Signal_F = 5.88%
hgun_ACPC2_F = 11.76%
hgun_P07_F = 11.76%
hgun_Rook40_F = 11.76%
Exile_Weapon_SA61 = 11.76%
*/
Pistols[] = {"hgun_Pistol_heavy_02_F", "Exile_Weapon_SA61", "hgun_P07_F", "hgun_ACPC2_F", "hgun_P07_F", "Exile_Weapon_Taurus", "hgun_Rook40_F", "hgun_ACPC2_F", "hgun_Pistol_01_F", "hgun_Pistol_heavy_01_F", "hgun_Rook40_F", "Exile_Weapon_Makarov", "Exile_Weapon_TaurusGold", "Exile_Weapon_SA61", "hgun_Pistol_Signal_F", "Exile_Weapon_Colt1911", "hgun_P07_khk_F"};
/*
Percental Item Spawn Chances of PistolAmmo:
6Rnd_GreenSignal_F = 2.44%
6Rnd_RedSignal_F = 2.44%
16Rnd_9x21_Mag = 2.44%
6Rnd_45ACP_Cylinder = 4.88%
10Rnd_9x21_Mag = 9.76%
11Rnd_45ACP_Mag = 9.76%
30Rnd_9x21_Mag = 9.76%
9Rnd_45ACP_Mag = 9.76%
Exile_Magazine_6Rnd_45ACP = 9.76%
Exile_Magazine_7Rnd_45ACP = 9.76%
Exile_Magazine_8Rnd_9x18 = 9.76%
Exile_Magazine_10Rnd_765x17_SA61 = 9.76%
Exile_Magazine_20Rnd_765x17_SA61 = 9.76%
*/
PistolAmmo[] = {"Exile_Magazine_20Rnd_765x17_SA61", "9Rnd_45ACP_Mag", "6Rnd_45ACP_Cylinder", "10Rnd_9x21_Mag", "6Rnd_45ACP_Cylinder", "9Rnd_45ACP_Mag", "Exile_Magazine_10Rnd_765x17_SA61", "Exile_Magazine_10Rnd_765x17_SA61", "Exile_Magazine_6Rnd_45ACP", "16Rnd_9x21_Mag", "Exile_Magazine_7Rnd_45ACP", "9Rnd_45ACP_Mag", "11Rnd_45ACP_Mag", "6Rnd_RedSignal_F", "Exile_Magazine_7Rnd_45ACP", "Exile_Magazine_20Rnd_765x17_SA61", "10Rnd_9x21_Mag", "Exile_Magazine_10Rnd_765x17_SA61", "30Rnd_9x21_Mag", "Exile_Magazine_6Rnd_45ACP", "10Rnd_9x21_Mag", "10Rnd_9x21_Mag", "Exile_Magazine_8Rnd_9x18", "30Rnd_9x21_Mag", "Exile_Magazine_20Rnd_765x17_SA61", "11Rnd_45ACP_Mag", "Exile_Magazine_8Rnd_9x18", "Exile_Magazine_6Rnd_45ACP", "30Rnd_9x21_Mag", "Exile_Magazine_8Rnd_9x18", "6Rnd_GreenSignal_F", "Exile_Magazine_20Rnd_765x17_SA61", "Exile_Magazine_7Rnd_45ACP", "Exile_Magazine_6Rnd_45ACP", "Exile_Magazine_8Rnd_9x18", "30Rnd_9x21_Mag", "Exile_Magazine_7Rnd_45ACP", "11Rnd_45ACP_Mag", "9Rnd_45ACP_Mag", "Exile_Magazine_10Rnd_765x17_SA61", "11Rnd_45ACP_Mag"};
/*
Percental Item Spawn Chances of PistolAttachments:
optic_MRD = 16.67%
optic_Yorris = 16.67%
muzzle_snds_acp = 33.33%
muzzle_snds_L = 33.33%
*/
PistolAttachments[] = {"muzzle_snds_acp", "muzzle_snds_L", "optic_Yorris", "muzzle_snds_acp", "muzzle_snds_L", "optic_MRD"};
/*
Percental Item Spawn Chances of Shotguns:
Exile_Weapon_M1014 = 100.00%
*/
Shotguns[] = {"Exile_Weapon_M1014"};
/*
Percental Item Spawn Chances of ShotgunAmmo:
Exile_Magazine_8Rnd_74Slug = 100.00%
*/
ShotgunAmmo[] = {"Exile_Magazine_8Rnd_74Slug"};
/*
Percental Item Spawn Chances of SMG:
SMG_01_F = 25.00%
SMG_02_F = 25.00%
SMG_05_F = 25.00%
hgun_PDW2000_F = 25.00%
*/
SMG[] = {"SMG_05_F", "SMG_02_F", "hgun_PDW2000_F", "SMG_01_F"};
/*
Percental Item Spawn Chances of SMGAmmo:
30Rnd_45ACP_Mag_SMG_01 = 16.67%
30Rnd_45ACP_Mag_SMG_01_Tracer_Green = 16.67%
30Rnd_9x21_Mag_SMG_02 = 16.67%
30Rnd_9x21_Mag_SMG_02_Tracer_Red = 16.67%
30Rnd_9x21_Mag_SMG_02_Tracer_Yellow = 16.67%
30Rnd_9x21_Mag_SMG_02_Tracer_Green = 16.67%
*/
SMGAmmo[] = {"30Rnd_9x21_Mag_SMG_02", "30Rnd_9x21_Mag_SMG_02_Tracer_Yellow", "30Rnd_45ACP_Mag_SMG_01_Tracer_Green", "30Rnd_9x21_Mag_SMG_02_Tracer_Red", "30Rnd_9x21_Mag_SMG_02_Tracer_Green", "30Rnd_45ACP_Mag_SMG_01"};
/*
Percental Item Spawn Chances of SMGAttachments:
optic_Holosight_smg = 16.67%
optic_Holosight_smg_blk_F = 16.67%
optic_ACO_grn_smg = 16.67%
optic_Aco_smg = 16.67%
optic_ACO_grn = 16.67%
optic_Aco = 16.67%
*/
SMGAttachments[] = {"optic_ACO_grn_smg", "optic_Holosight_smg_blk_F", "optic_Holosight_smg", "optic_ACO_grn", "optic_Aco", "optic_Aco_smg"};
/*
Percental Item Spawn Chances of Rifles:
arifle_Katiba_GL_F = 0.71%
arifle_Mk20_GL_F = 0.71%
arifle_MX_GL_Black_F = 0.71%
arifle_MX_GL_F = 0.71%
arifle_MXM_F = 0.71%
arifle_TRG21_GL_F = 0.71%
Exile_Weapon_AK107_GL = 0.71%
Exile_Weapon_AK74_GL = 0.71%
arifle_AK12_GL_F = 1.43%
arifle_AKM_F = 1.43%
arifle_AKM_FL_F = 1.43%
arifle_AKS_F = 1.43%
arifle_ARX_blk_F = 1.43%
arifle_ARX_ghex_F = 1.43%
arifle_ARX_hex_F = 1.43%
arifle_CTAR_blk_F = 1.43%
arifle_CTAR_ghex_F = 1.43%
arifle_CTAR_GL_blk_F = 1.43%
arifle_CTAR_hex_F = 1.43%
arifle_CTARS_blk_F = 1.43%
arifle_CTARS_ghex_F = 1.43%
arifle_CTARS_hex_F = 1.43%
arifle_Katiba_F = 1.43%
arifle_Mk20_F = 1.43%
arifle_Mk20C_F = 1.43%
arifle_MX_Black_F = 1.43%
arifle_MX_F = 1.43%
arifle_MXC_Black_F = 1.43%
arifle_MXC_F = 1.43%
arifle_MXM_Black_F = 1.43%
arifle_SDAR_F = 1.43%
arifle_SPAR_01_blk_F = 1.43%
arifle_SPAR_01_GL_blk_F = 1.43%
arifle_SPAR_01_GL_khk_F = 1.43%
arifle_SPAR_01_GL_snd_F = 1.43%
arifle_SPAR_01_khk_F = 1.43%
arifle_SPAR_01_snd_F = 1.43%
arifle_SPAR_02_blk_F = 1.43%
arifle_SPAR_02_khk_F = 1.43%
arifle_SPAR_02_snd_F = 1.43%
arifle_SPAR_03_blk_F = 1.43%
arifle_SPAR_03_khk_F = 1.43%
arifle_SPAR_03_snd_F = 1.43%
arifle_TRG20_F = 1.43%
arifle_TRG21_F = 1.43%
Exile_Weapon_AK107 = 1.43%
Exile_Weapon_AK74 = 1.43%
Exile_Weapon_DMR = 1.43%
arifle_MXM_khk_F = 2.14%
Exile_Weapon_AK47 = 2.14%
Exile_Weapon_AKS_Gold = 2.14%
Exile_Weapon_SVD = 2.14%
Exile_Weapon_SVDCamo = 2.14%
Exile_Weapon_VSSVintorez = 2.14%
arifle_MX_GL_khk_F = 2.14%
arifle_AK12_F = 2.14%
Exile_Weapon_CZ550 = 2.14%
arifle_MX_khk_F = 2.14%
arifle_MXC_khk_F = 2.14%
Exile_Weapon_M4 = 2.14%
Exile_Weapon_M16A4 = 2.14%
Exile_Weapon_M16A2 = 2.14%
Exile_Weapon_LeeEnfield = 7.14%
*/
Rifles[] = {"arifle_ARX_ghex_F", "Exile_Weapon_SVD", "arifle_Katiba_F", "arifle_MXM_Black_F", "arifle_SPAR_02_snd_F", "arifle_MX_Black_F", "arifle_MX_F", "arifle_AK12_F", "Exile_Weapon_DMR", "arifle_SPAR_02_blk_F", "Exile_Weapon_DMR", "arifle_MXC_khk_F", "arifle_SPAR_01_GL_khk_F", "arifle_SPAR_03_snd_F", "arifle_MXC_Black_F", "Exile_Weapon_VSSVintorez", "Exile_Weapon_M16A4", "Exile_Weapon_M4", "arifle_TRG21_F", "Exile_Weapon_SVD", "arifle_MX_khk_F", "arifle_AKM_FL_F", "arifle_SPAR_02_khk_F", "arifle_MXC_khk_F", "arifle_SPAR_03_khk_F", "Exile_Weapon_M4", "arifle_MXM_F", "arifle_CTAR_GL_blk_F", "arifle_SPAR_01_blk_F", "Exile_Weapon_AK47", "arifle_SPAR_01_khk_F", "Exile_Weapon_LeeEnfield", "Exile_Weapon_LeeEnfield", "arifle_TRG21_F", "arifle_SPAR_01_snd_F", "Exile_Weapon_AK74", "Exile_Weapon_LeeEnfield", "arifle_MXC_F", "arifle_MXC_khk_F", "arifle_Katiba_GL_F", "arifle_Mk20C_F", "arifle_SPAR_03_blk_F", "Exile_Weapon_M16A2", "arifle_CTAR_hex_F", "arifle_ARX_blk_F", "arifle_ARX_ghex_F", "arifle_SPAR_01_GL_khk_F", "Exile_Weapon_M16A2", "arifle_SPAR_03_khk_F", "Exile_Weapon_LeeEnfield", "arifle_SPAR_01_GL_snd_F", "Exile_Weapon_LeeEnfield", "Exile_Weapon_AKS_Gold", "arifle_MXM_khk_F", "arifle_MX_GL_F", "Exile_Weapon_M16A4", "Exile_Weapon_AK107", "arifle_CTAR_hex_F", "arifle_CTARS_ghex_F", "arifle_MX_khk_F", "arifle_CTARS_ghex_F", "Exile_Weapon_CZ550", "Exile_Weapon_M16A4", "arifle_CTAR_GL_blk_F", "arifle_CTAR_blk_F", "arifle_MXM_khk_F", "arifle_CTARS_blk_F", "arifle_CTAR_ghex_F", "Exile_Weapon_M16A2", "arifle_AK12_F", "arifle_CTARS_blk_F", "Exile_Weapon_CZ550", "Exile_Weapon_LeeEnfield", "Exile_Weapon_LeeEnfield", "arifle_MXC_Black_F", "arifle_MX_khk_F", "arifle_AK12_GL_F", "Exile_Weapon_VSSVintorez", "Exile_Weapon_LeeEnfield", "arifle_SPAR_02_blk_F", "arifle_TRG20_F", "Exile_Weapon_AKS_Gold", "arifle_SPAR_02_snd_F", "arifle_SPAR_03_blk_F", "arifle_Katiba_F", "Exile_Weapon_AKS_Gold", "arifle_TRG21_GL_F", "arifle_ARX_hex_F", "arifle_CTAR_blk_F", "arifle_Mk20_F", "arifle_MXC_F", "arifle_Mk20C_F", "Exile_Weapon_AK74", "arifle_SPAR_01_khk_F", "arifle_MXM_Black_F", "arifle_Mk20_GL_F", "arifle_SPAR_01_GL_blk_F", "Exile_Weapon_AK47", "arifle_CTARS_hex_F", "arifle_SDAR_F", "arifle_MX_GL_khk_F", "arifle_AKM_F", "arifle_Mk20_F", "arifle_AKM_FL_F", "arifle_SPAR_03_snd_F", "arifle_SDAR_F", "arifle_CTAR_ghex_F", "arifle_MX_GL_Black_F", "Exile_Weapon_M4", "arifle_CTARS_hex_F", "arifle_AK12_F", "Exile_Weapon_AK74_GL", "Exile_Weapon_LeeEnfield", "arifle_SPAR_01_blk_F", "Exile_Weapon_AK47", "Exile_Weapon_AK107_GL", "Exile_Weapon_LeeEnfield", "arifle_MX_GL_khk_F", "arifle_MX_F", "Exile_Weapon_AK107", "arifle_AKS_F", "arifle_MXM_khk_F", "arifle_SPAR_01_GL_blk_F", "arifle_ARX_blk_F", "arifle_TRG20_F", "arifle_ARX_hex_F", "arifle_AK12_GL_F", "arifle_SPAR_01_GL_snd_F", "arifle_SPAR_02_khk_F", "Exile_Weapon_SVD", "arifle_SPAR_01_snd_F", "arifle_AKS_F", "Exile_Weapon_SVDCamo", "arifle_AKM_F", "arifle_MX_Black_F", "Exile_Weapon_VSSVintorez", "Exile_Weapon_SVDCamo", "Exile_Weapon_SVDCamo", "arifle_MX_GL_khk_F", "Exile_Weapon_CZ550"};
/*
Percental Item Spawn Chances of RifleAmmo:
20Rnd_556x45_UW_mag = 2.20%
30Rnd_556x45_Stanag = 2.20%
30Rnd_556x45_Stanag_green = 2.20%
30Rnd_556x45_Stanag_red = 2.20%
30Rnd_556x45_Stanag_Tracer_Green = 2.20%
30Rnd_556x45_Stanag_Tracer_Red = 2.20%
30Rnd_556x45_Stanag_Tracer_Yellow = 2.20%
30Rnd_65x39_caseless_green = 2.20%
30Rnd_65x39_caseless_green_mag_Tracer = 2.20%
30Rnd_65x39_caseless_mag = 2.20%
30Rnd_65x39_caseless_mag_Tracer = 2.20%
Exile_Magazine_10Rnd_303 = 10.99%
Exile_Magazine_30Rnd_762x39_AK = 2.20%
Exile_Magazine_30Rnd_545x39_AK = 2.20%
Exile_Magazine_30Rnd_545x39_AK_Green = 2.20%
Exile_Magazine_30Rnd_545x39_AK_Red = 2.20%
Exile_Magazine_30Rnd_545x39_AK_White = 2.20%
Exile_Magazine_30Rnd_545x39_AK_Yellow = 2.20%
Exile_Magazine_20Rnd_762x51_DMR = 1.10%
Exile_Magazine_20Rnd_762x51_DMR_Yellow = 1.10%
Exile_Magazine_20Rnd_762x51_DMR_Red = 1.10%
Exile_Magazine_20Rnd_762x51_DMR_Green = 1.10%
Exile_Magazine_20Rnd_762x51_DMR_White = 1.10%
Exile_Magazine_5Rnd_22LR = 2.20%
Exile_Magazine_10Rnd_762x54 = 2.20%
Exile_Magazine_10Rnd_9x39 = 2.20%
Exile_Magazine_20Rnd_9x39 = 2.20%
30Rnd_762x39_Mag_F = 2.20%
30Rnd_762x39_Mag_Green_F = 2.20%
30Rnd_762x39_Mag_Tracer_F = 2.20%
30Rnd_762x39_Mag_Tracer_Green_F = 2.20%
30Rnd_762x39_AK47_M = 2.20%
30Rnd_545x39_Mag_F = 2.20%
30Rnd_545x39_Mag_Green_F = 2.20%
30Rnd_545x39_Mag_Tracer_F = 2.20%
30Rnd_545x39_Mag_Tracer_Green_F = 2.20%
10Rnd_50BW_Mag_F = 2.20%
30Rnd_580x42_Mag_F = 2.20%
30Rnd_580x42_Mag_Tracer_F = 2.20%
100Rnd_580x42_Mag_F = 2.20%
100Rnd_580x42_Mag_Tracer_F = 2.20%
150Rnd_556x45_Drum_Mag_F = 2.20%
150Rnd_556x45_Drum_Mag_Tracer_F = 2.20%
20Rnd_762x51_Mag = 2.20%
*/
RifleAmmo[] = {"30Rnd_762x39_Mag_Green_F", "30Rnd_762x39_Mag_F", "30Rnd_545x39_Mag_Green_F", "Exile_Magazine_5Rnd_22LR", "Exile_Magazine_30Rnd_545x39_AK_Green", "30Rnd_545x39_Mag_Tracer_Green_F", "30Rnd_556x45_Stanag_green", "150Rnd_556x45_Drum_Mag_F", "150Rnd_556x45_Drum_Mag_Tracer_F", "30Rnd_580x42_Mag_Tracer_F", "30Rnd_556x45_Stanag_Tracer_Green", "30Rnd_762x39_AK47_M", "20Rnd_762x51_Mag", "Exile_Magazine_30Rnd_545x39_AK", "20Rnd_556x45_UW_mag", "Exile_Magazine_10Rnd_762x54", "30Rnd_762x39_Mag_Tracer_Green_F", "Exile_Magazine_10Rnd_9x39", "30Rnd_762x39_Mag_Tracer_F", "30Rnd_580x42_Mag_F", "100Rnd_580x42_Mag_Tracer_F", "30Rnd_545x39_Mag_Tracer_Green_F", "30Rnd_545x39_Mag_Green_F", "Exile_Magazine_10Rnd_303", "30Rnd_65x39_caseless_green_mag_Tracer", "Exile_Magazine_30Rnd_545x39_AK_Green", "30Rnd_762x39_Mag_Green_F", "Exile_Magazine_20Rnd_9x39", "100Rnd_580x42_Mag_F", "Exile_Magazine_20Rnd_762x51_DMR_Yellow", "30Rnd_65x39_caseless_mag", "30Rnd_65x39_caseless_mag", "30Rnd_556x45_Stanag_red", "30Rnd_65x39_caseless_green", "30Rnd_762x39_AK47_M", "30Rnd_556x45_Stanag_Tracer_Red", "100Rnd_580x42_Mag_Tracer_F", "Exile_Magazine_10Rnd_9x39", "100Rnd_580x42_Mag_F", "Exile_Magazine_20Rnd_762x51_DMR_Green", "20Rnd_556x45_UW_mag", "Exile_Magazine_30Rnd_762x39_AK", "30Rnd_545x39_Mag_F", "Exile_Magazine_5Rnd_22LR", "30Rnd_556x45_Stanag_Tracer_Green", "30Rnd_65x39_caseless_mag_Tracer", "Exile_Magazine_30Rnd_545x39_AK_White", "Exile_Magazine_20Rnd_762x51_DMR", "Exile_Magazine_10Rnd_303", "30Rnd_545x39_Mag_F", "20Rnd_762x51_Mag", "10Rnd_50BW_Mag_F", "Exile_Magazine_10Rnd_303", "30Rnd_556x45_Stanag", "30Rnd_545x39_Mag_Tracer_F", "10Rnd_50BW_Mag_F", "30Rnd_762x39_Mag_F", "Exile_Magazine_30Rnd_545x39_AK_Red", "30Rnd_556x45_Stanag_red", "30Rnd_556x45_Stanag", "30Rnd_556x45_Stanag_Tracer_Red", "Exile_Magazine_30Rnd_545x39_AK_White", "Exile_Magazine_10Rnd_303", "30Rnd_580x42_Mag_F", "Exile_Magazine_10Rnd_303", "30Rnd_545x39_Mag_Tracer_F", "30Rnd_65x39_caseless_green_mag_Tracer", "150Rnd_556x45_Drum_Mag_F", "Exile_Magazine_20Rnd_762x51_DMR_Red", "Exile_Magazine_30Rnd_545x39_AK_Yellow", "Exile_Magazine_20Rnd_9x39", "Exile_Magazine_10Rnd_303", "30Rnd_762x39_Mag_Tracer_Green_F", "Exile_Magazine_30Rnd_762x39_AK", "Exile_Magazine_30Rnd_545x39_AK", "Exile_Magazine_10Rnd_762x54", "Exile_Magazine_10Rnd_303", "30Rnd_65x39_caseless_mag_Tracer", "Exile_Magazine_30Rnd_545x39_AK_Red", "30Rnd_762x39_Mag_Tracer_F", "30Rnd_556x45_Stanag_Tracer_Yellow", "Exile_Magazine_10Rnd_303", "150Rnd_556x45_Drum_Mag_Tracer_F", "Exile_Magazine_10Rnd_303", "Exile_Magazine_10Rnd_303", "30Rnd_556x45_Stanag_green", "Exile_Magazine_20Rnd_762x51_DMR_White", "Exile_Magazine_30Rnd_545x39_AK_Yellow", "30Rnd_556x45_Stanag_Tracer_Yellow", "30Rnd_65x39_caseless_green", "30Rnd_580x42_Mag_Tracer_F"};
/*
Percental Item Spawn Chances of RifleAttachments:
muzzle_snds_M = 3.39%
muzzle_snds_H = 3.39%
muzzle_snds_H_khk_F = 3.39%
muzzle_snds_H_snd_F = 3.39%
muzzle_snds_58_blk_F = 3.39%
muzzle_snds_m_khk_F = 3.39%
muzzle_snds_m_snd_F = 3.39%
muzzle_snds_58_wdm_F = 3.39%
muzzle_snds_65_TI_blk_F = 3.39%
muzzle_snds_65_TI_hex_F = 3.39%
muzzle_snds_65_TI_ghex_F = 3.39%
muzzle_snds_H_MG_blk_F = 3.39%
muzzle_snds_H_MG_khk_F = 3.39%
optic_Arco = 3.39%
optic_Arco_blk_F = 3.39%
optic_Arco_ghex_F = 3.39%
optic_Hamr = 3.39%
optic_Hamr_khk_F = 3.39%
optic_Holosight = 3.39%
optic_Holosight_blk_F = 3.39%
optic_Holosight_khk_F = 3.39%
acc_flashlight = 3.39%
acc_pointer_IR = 3.39%
optic_MRCO = 3.39%
optic_DMS = 3.39%
optic_DMS_ghex_F = 3.39%
optic_ERCO_blk_F = 3.39%
optic_ERCO_khk_F = 3.39%
optic_ERCO_snd_F = 3.39%
optic_NVS = 1.69%
*/
RifleAttachments[] = {"muzzle_snds_H", "optic_ERCO_khk_F", "optic_Holosight_blk_F", "muzzle_snds_65_TI_ghex_F", "muzzle_snds_H_MG_khk_F", "muzzle_snds_H_snd_F", "optic_DMS_ghex_F", "muzzle_snds_65_TI_hex_F", "optic_Arco", "optic_Holosight_khk_F", "muzzle_snds_65_TI_hex_F", "optic_Arco_ghex_F", "muzzle_snds_65_TI_ghex_F", "muzzle_snds_H_MG_khk_F", "muzzle_snds_M", "muzzle_snds_M", "muzzle_snds_58_wdm_F", "optic_ERCO_blk_F", "optic_DMS_ghex_F", "muzzle_snds_m_khk_F", "muzzle_snds_m_snd_F", "optic_ERCO_blk_F", "optic_Hamr_khk_F", "optic_NVS", "optic_Hamr", "muzzle_snds_H_khk_F", "muzzle_snds_H_MG_blk_F", "optic_ERCO_snd_F", "acc_pointer_IR", "muzzle_snds_H_khk_F", "optic_ERCO_snd_F", "muzzle_snds_H", "optic_Holosight", "muzzle_snds_65_TI_blk_F", "optic_Holosight_khk_F", "muzzle_snds_58_wdm_F", "muzzle_snds_H_MG_blk_F", "acc_flashlight", "muzzle_snds_58_blk_F", "optic_MRCO", "optic_ERCO_khk_F", "optic_DMS", "muzzle_snds_m_khk_F", "optic_Arco_blk_F", "optic_Arco_blk_F", "muzzle_snds_m_snd_F", "optic_Hamr", "muzzle_snds_65_TI_blk_F", "optic_Holosight", "optic_Holosight_blk_F", "acc_flashlight", "optic_Hamr_khk_F", "muzzle_snds_H_snd_F", "optic_Arco_ghex_F", "acc_pointer_IR", "optic_DMS", "optic_MRCO", "muzzle_snds_58_blk_F", "optic_Arco"};
/*
Percental Item Spawn Chances of LMG:
arifle_MX_SW_Black_F = 12.50%
arifle_MX_SW_F = 12.50%
LMG_Mk200_F = 12.50%
LMG_Zafir_F = 12.50%
Exile_Weapon_RPK = 12.50%
Exile_Weapon_PK = 12.50%
Exile_Weapon_PKP = 12.50%
LMG_03_F = 12.50%
*/
LMG[] = {"LMG_Zafir_F", "Exile_Weapon_RPK", "Exile_Weapon_PKP", "arifle_MX_SW_F", "LMG_03_F", "Exile_Weapon_PK", "LMG_Mk200_F", "arifle_MX_SW_Black_F"};
/*
Percental Item Spawn Chances of LMGAmmo:
100Rnd_65x39_caseless_mag = 7.69%
100Rnd_65x39_caseless_mag_Tracer = 11.54%
150Rnd_762x54_Box = 11.54%
150Rnd_762x54_Box_Tracer = 3.85%
130Rnd_338_Mag = 19.23%
150Rnd_93x64_Mag = 19.23%
Exile_Magazine_45Rnd_545x39_RPK_Green = 3.85%
Exile_Magazine_75Rnd_545x39_RPK_Green = 3.85%
Exile_Magazine_100Rnd_762x54_PK_Green = 3.85%
200Rnd_556x45_Box_F = 3.85%
200Rnd_556x45_Box_Red_F = 3.85%
200Rnd_556x45_Box_Tracer_F = 3.85%
200Rnd_556x45_Box_Tracer_Red_F = 3.85%
*/
LMGAmmo[] = {"150Rnd_93x64_Mag", "150Rnd_93x64_Mag", "200Rnd_556x45_Box_F", "130Rnd_338_Mag", "150Rnd_93x64_Mag", "Exile_Magazine_100Rnd_762x54_PK_Green", "200Rnd_556x45_Box_Tracer_Red_F", "Exile_Magazine_45Rnd_545x39_RPK_Green", "130Rnd_338_Mag", "130Rnd_338_Mag", "100Rnd_65x39_caseless_mag", "150Rnd_93x64_Mag", "100Rnd_65x39_caseless_mag_Tracer", "150Rnd_762x54_Box", "200Rnd_556x45_Box_Red_F", "130Rnd_338_Mag", "Exile_Magazine_75Rnd_545x39_RPK_Green", "150Rnd_762x54_Box", "150Rnd_762x54_Box", "100Rnd_65x39_caseless_mag_Tracer", "100Rnd_65x39_caseless_mag", "150Rnd_93x64_Mag", "150Rnd_762x54_Box_Tracer", "200Rnd_556x45_Box_Tracer_F", "130Rnd_338_Mag", "100Rnd_65x39_caseless_mag_Tracer"};
/*
Percental Item Spawn Chances of Snipers:
srifle_DMR_01_F = 9.09%
srifle_EBR_F = 9.09%
srifle_GM6_F = 9.09%
srifle_LRR_F = 9.09%
srifle_LRR_tna_F = 9.09%
srifle_GM6_ghex_F = 9.09%
srifle_DMR_07_blk_F = 9.09%
srifle_DMR_07_hex_F = 9.09%
srifle_DMR_07_ghex_F = 9.09%
Exile_Weapon_m107 = 9.09%
Exile_Weapon_ksvk = 9.09%
*/
Snipers[] = {"srifle_LRR_F", "Exile_Weapon_m107", "srifle_DMR_07_hex_F", "srifle_DMR_07_ghex_F", "srifle_GM6_ghex_F", "srifle_DMR_07_blk_F", "Exile_Weapon_ksvk", "srifle_GM6_F", "srifle_DMR_01_F", "srifle_EBR_F", "srifle_LRR_tna_F"};
/*
Percental Item Spawn Chances of SniperAmmo:
Exile_Magazine_5Rnd_127x108_APDS_Bullet_Cam_Mag = 0.74%
Exile_Magazine_5Rnd_127x108_APDS_KSVK_Bullet_Cam_Mag = 0.74%
Exile_Magazine_5Rnd_127x108_KSVK_Bullet_Cam_Mag = 1.48%
Exile_Magazine_5Rnd_127x108_Bullet_Cam_Mag = 1.48%
Exile_Magazine_10Rnd_127x99_m107_Bullet_Cam_Mag = 2.22%
Exile_Magazine_7Rnd_408_Bullet_Cam_Mag = 2.22%
Exile_Magazine_10Rnd_338_Bullet_Cam_Mag = 3.70%
Exile_Magazine_10Rnd_93x64_DMR_05_Bullet_Cam_Mag = 3.70%
Exile_Magazine_5Rnd_127x108_APDS_KSVK = 5.93%
5Rnd_127x108_APDS_Mag = 5.93%
5Rnd_127x108_Mag = 7.41%
Exile_Magazine_10Rnd_127x99_m107 = 7.41%
Exile_Magazine_5Rnd_127x108_KSVK = 7.41%
7Rnd_408_Mag = 7.41%
10Rnd_762x54_Mag = 12.59%
20Rnd_762x51_Mag = 14.07%
20Rnd_650x39_Cased_Mag_F = 15.56%
*/
SniperAmmo[] = {"Exile_Magazine_5Rnd_127x108_APDS_KSVK", "20Rnd_762x51_Mag", "20Rnd_650x39_Cased_Mag_F", "Exile_Magazine_5Rnd_127x108_APDS_KSVK", "10Rnd_762x54_Mag", "5Rnd_127x108_Mag", "Exile_Magazine_10Rnd_127x99_m107_Bullet_Cam_Mag", "10Rnd_762x54_Mag", "5Rnd_127x108_APDS_Mag", "Exile_Magazine_7Rnd_408_Bullet_Cam_Mag", "Exile_Magazine_10Rnd_127x99_m107", "10Rnd_762x54_Mag", "20Rnd_762x51_Mag", "5Rnd_127x108_Mag", "5Rnd_127x108_Mag", "10Rnd_762x54_Mag", "20Rnd_762x51_Mag", "10Rnd_762x54_Mag", "Exile_Magazine_10Rnd_338_Bullet_Cam_Mag", "20Rnd_650x39_Cased_Mag_F", "10Rnd_762x54_Mag", "20Rnd_650x39_Cased_Mag_F", "10Rnd_762x54_Mag", "5Rnd_127x108_Mag", "10Rnd_762x54_Mag", "5Rnd_127x108_APDS_Mag", "20Rnd_650x39_Cased_Mag_F", "Exile_Magazine_10Rnd_93x64_DMR_05_Bullet_Cam_Mag", "5Rnd_127x108_APDS_Mag", "10Rnd_762x54_Mag", "5Rnd_127x108_APDS_Mag", "20Rnd_650x39_Cased_Mag_F", "20Rnd_650x39_Cased_Mag_F", "10Rnd_762x54_Mag", "Exile_Magazine_10Rnd_127x99_m107_Bullet_Cam_Mag", "Exile_Magazine_5Rnd_127x108_KSVK_Bullet_Cam_Mag", "7Rnd_408_Mag", "Exile_Magazine_10Rnd_127x99_m107", "Exile_Magazine_5Rnd_127x108_APDS_KSVK", "20Rnd_762x51_Mag", "Exile_Magazine_10Rnd_127x99_m107", "20Rnd_762x51_Mag", "Exile_Magazine_5Rnd_127x108_KSVK", "Exile_Magazine_10Rnd_338_Bullet_Cam_Mag", "20Rnd_762x51_Mag", "20Rnd_650x39_Cased_Mag_F", "Exile_Magazine_5Rnd_127x108_Bullet_Cam_Mag", "10Rnd_762x54_Mag", "7Rnd_408_Mag", "Exile_Magazine_5Rnd_127x108_KSVK", "Exile_Magazine_10Rnd_127x99_m107", "20Rnd_650x39_Cased_Mag_F", "Exile_Magazine_10Rnd_127x99_m107", "20Rnd_762x51_Mag", "20Rnd_650x39_Cased_Mag_F", "Exile_Magazine_10Rnd_127x99_m107", "20Rnd_762x51_Mag", "Exile_Magazine_5Rnd_127x108_KSVK", "10Rnd_762x54_Mag", "7Rnd_408_Mag", "10Rnd_762x54_Mag", "Exile_Magazine_5Rnd_127x108_KSVK", "5Rnd_127x108_Mag", "Exile_Magazine_5Rnd_127x108_APDS_KSVK", "Exile_Magazine_10Rnd_93x64_DMR_05_Bullet_Cam_Mag", "20Rnd_650x39_Cased_Mag_F", "20Rnd_762x51_Mag", "20Rnd_762x51_Mag", "20Rnd_762x51_Mag", "Exile_Magazine_10Rnd_93x64_DMR_05_Bullet_Cam_Mag", "Exile_Magazine_5Rnd_127x108_APDS_KSVK", "5Rnd_127x108_Mag", "Exile_Magazine_5Rnd_127x108_KSVK_Bullet_Cam_Mag", "20Rnd_762x51_Mag", "5Rnd_127x108_APDS_Mag", "7Rnd_408_Mag", "Exile_Magazine_10Rnd_338_Bullet_Cam_Mag", "Exile_Magazine_10Rnd_93x64_DMR_05_Bullet_Cam_Mag", "5Rnd_127x108_APDS_Mag", "Exile_Magazine_10Rnd_338_Bullet_Cam_Mag", "Exile_Magazine_5Rnd_127x108_APDS_KSVK", "Exile_Magazine_10Rnd_127x99_m107_Bullet_Cam_Mag", "20Rnd_650x39_Cased_Mag_F", "20Rnd_650x39_Cased_Mag_F", "20Rnd_762x51_Mag", "20Rnd_650x39_Cased_Mag_F", "20Rnd_650x39_Cased_Mag_F", "5Rnd_127x108_APDS_Mag", "20Rnd_650x39_Cased_Mag_F", "20Rnd_650x39_Cased_Mag_F", "5Rnd_127x108_APDS_Mag", "Exile_Magazine_5Rnd_127x108_KSVK", "Exile_Magazine_5Rnd_127x108_KSVK", "7Rnd_408_Mag", "20Rnd_762x51_Mag", "10Rnd_762x54_Mag", "5Rnd_127x108_Mag", "Exile_Magazine_5Rnd_127x108_KSVK", "Exile_Magazine_5Rnd_127x108_KSVK", "Exile_Magazine_10Rnd_93x64_DMR_05_Bullet_Cam_Mag", "Exile_Magazine_10Rnd_127x99_m107", "5Rnd_127x108_Mag", "10Rnd_762x54_Mag", "Exile_Magazine_5Rnd_127x108_KSVK", "20Rnd_650x39_Cased_Mag_F", "5Rnd_127x108_Mag", "7Rnd_408_Mag", "20Rnd_762x51_Mag", "20Rnd_650x39_Cased_Mag_F", "20Rnd_762x51_Mag", "20Rnd_650x39_Cased_Mag_F", "Exile_Magazine_10Rnd_338_Bullet_Cam_Mag", "Exile_Magazine_10Rnd_127x99_m107", "10Rnd_762x54_Mag", "7Rnd_408_Mag", "7Rnd_408_Mag", "Exile_Magazine_5Rnd_127x108_APDS_KSVK", "Exile_Magazine_7Rnd_408_Bullet_Cam_Mag", "Exile_Magazine_5Rnd_127x108_APDS_Bullet_Cam_Mag", "20Rnd_762x51_Mag", "Exile_Magazine_5Rnd_127x108_APDS_KSVK", "7Rnd_408_Mag", "Exile_Magazine_7Rnd_408_Bullet_Cam_Mag", "Exile_Magazine_5Rnd_127x108_APDS_KSVK_Bullet_Cam_Mag", "20Rnd_762x51_Mag", "5Rnd_127x108_Mag", "Exile_Magazine_5Rnd_127x108_Bullet_Cam_Mag", "10Rnd_762x54_Mag", "Exile_Magazine_5Rnd_127x108_KSVK", "7Rnd_408_Mag", "20Rnd_762x51_Mag", "Exile_Magazine_10Rnd_127x99_m107", "Exile_Magazine_10Rnd_127x99_m107", "20Rnd_650x39_Cased_Mag_F", "20Rnd_650x39_Cased_Mag_F"};
/*
Percental Item Spawn Chances of SniperAttachments:
muzzle_snds_B_khk_F = 11.11%
muzzle_snds_B_snd_F = 11.11%
muzzle_snds_B = 11.11%
optic_LRPS = 11.11%
optic_LRPS_ghex_F = 11.11%
optic_LRPS_tna_F = 11.11%
optic_SOS = 11.11%
optic_SOS_khk_F = 11.11%
optic_DMS = 11.11%
*/
SniperAttachments[] = {"muzzle_snds_B_khk_F", "optic_SOS_khk_F", "optic_DMS", "muzzle_snds_B_snd_F", "optic_SOS", "optic_LRPS_ghex_F", "muzzle_snds_B", "optic_LRPS", "optic_LRPS_tna_F"};
/*
Percental Item Spawn Chances of DLCRifles:
srifle_DMR_03_F = 4.05%
srifle_DMR_03_khaki_F = 4.05%
srifle_DMR_03_tan_F = 4.05%
srifle_DMR_03_woodland_F = 4.05%
srifle_DMR_06_camo_F = 4.05%
srifle_DMR_06_olive_F = 4.05%
srifle_DMR_02_camo_F = 8.11%
srifle_DMR_02_F = 8.11%
srifle_DMR_02_sniper_F = 8.11%
srifle_DMR_04_F = 9.46%
srifle_DMR_04_Tan_F = 9.46%
srifle_DMR_05_blk_F = 10.81%
srifle_DMR_05_hex_F = 10.81%
srifle_DMR_05_tan_F = 10.81%
*/
DLCRifles[] = {"srifle_DMR_05_tan_F", "srifle_DMR_05_hex_F", "srifle_DMR_03_tan_F", "srifle_DMR_03_tan_F", "srifle_DMR_05_blk_F", "srifle_DMR_06_olive_F", "srifle_DMR_05_hex_F", "srifle_DMR_02_sniper_F", "srifle_DMR_04_F", "srifle_DMR_06_olive_F", "srifle_DMR_02_sniper_F", "srifle_DMR_02_camo_F", "srifle_DMR_05_tan_F", "srifle_DMR_05_hex_F", "srifle_DMR_04_F", "srifle_DMR_06_camo_F", "srifle_DMR_05_hex_F", "srifle_DMR_02_sniper_F", "srifle_DMR_03_F", "srifle_DMR_04_Tan_F", "srifle_DMR_02_F", "srifle_DMR_02_sniper_F", "srifle_DMR_03_khaki_F", "srifle_DMR_02_camo_F", "srifle_DMR_05_blk_F", "srifle_DMR_06_olive_F", "srifle_DMR_04_Tan_F", "srifle_DMR_05_hex_F", "srifle_DMR_06_camo_F", "srifle_DMR_04_F", "srifle_DMR_05_blk_F", "srifle_DMR_02_F", "srifle_DMR_03_woodland_F", "srifle_DMR_04_Tan_F", "srifle_DMR_02_F", "srifle_DMR_03_F", "srifle_DMR_03_khaki_F", "srifle_DMR_02_camo_F", "srifle_DMR_04_F", "srifle_DMR_05_tan_F", "srifle_DMR_02_sniper_F", "srifle_DMR_05_blk_F", "srifle_DMR_04_Tan_F", "srifle_DMR_02_camo_F", "srifle_DMR_05_tan_F", "srifle_DMR_02_camo_F", "srifle_DMR_05_blk_F", "srifle_DMR_04_F", "srifle_DMR_05_tan_F", "srifle_DMR_03_woodland_F", "srifle_DMR_05_blk_F", "srifle_DMR_05_blk_F", "srifle_DMR_04_Tan_F", "srifle_DMR_04_F", "srifle_DMR_05_tan_F", "srifle_DMR_02_F", "srifle_DMR_02_F", "srifle_DMR_04_Tan_F", "srifle_DMR_02_F", "srifle_DMR_05_blk_F", "srifle_DMR_05_tan_F", "srifle_DMR_02_camo_F", "srifle_DMR_05_hex_F", "srifle_DMR_03_khaki_F", "srifle_DMR_04_Tan_F", "srifle_DMR_05_hex_F", "srifle_DMR_05_tan_F", "srifle_DMR_02_sniper_F", "srifle_DMR_03_woodland_F", "srifle_DMR_05_hex_F", "srifle_DMR_03_tan_F", "srifle_DMR_06_camo_F", "srifle_DMR_04_F", "srifle_DMR_03_F"};
/*
Percental Item Spawn Chances of DLCAmmo:
10Rnd_127x54_Mag = 20.00%
20Rnd_762x51_Mag = 20.00%
10Rnd_338_Mag = 30.00%
10Rnd_93x64_DMR_05_Mag = 30.00%
*/
DLCAmmo[] = {"10Rnd_93x64_DMR_05_Mag", "10Rnd_93x64_DMR_05_Mag", "10Rnd_338_Mag", "20Rnd_762x51_Mag", "10Rnd_127x54_Mag", "10Rnd_338_Mag", "10Rnd_127x54_Mag", "20Rnd_762x51_Mag", "10Rnd_338_Mag", "10Rnd_93x64_DMR_05_Mag"};
/*
Percental Item Spawn Chances of DLCOptics:
optic_AMS = 14.29%
optic_AMS_khk = 14.29%
optic_AMS_snd = 14.29%
optic_KHS_blk = 14.29%
optic_KHS_hex = 14.29%
optic_KHS_old = 14.29%
optic_KHS_tan = 14.29%
*/
DLCOptics[] = {"optic_KHS_hex", "optic_KHS_old", "optic_AMS_snd", "optic_AMS_khk", "optic_AMS", "optic_KHS_blk", "optic_KHS_tan"};
/*
Percental Item Spawn Chances of DLCSupressor:
muzzle_snds_338_black = 16.67%
muzzle_snds_338_green = 16.67%
muzzle_snds_338_sand = 16.67%
muzzle_snds_93mmg = 16.67%
muzzle_snds_93mmg_tan = 16.67%
muzzle_snds_B = 16.67%
*/
DLCSupressor[] = {"muzzle_snds_93mmg_tan", "muzzle_snds_338_black", "muzzle_snds_338_green", "muzzle_snds_B", "muzzle_snds_338_sand", "muzzle_snds_93mmg"};
/*
Percental Item Spawn Chances of EpicWeapons:
MMG_01_hex_F = 20.00%
MMG_01_tan_F = 20.00%
MMG_02_black_F = 20.00%
MMG_02_camo_F = 20.00%
MMG_02_sand_F = 20.00%
*/
EpicWeapons[] = {"MMG_02_black_F", "MMG_01_hex_F", "MMG_02_camo_F", "MMG_01_tan_F", "MMG_02_sand_F"};
/*
Percental Item Spawn Chances of Bipods:
bipod_03_F_oli = 11.11%
bipod_03_F_blk = 11.11%
bipod_02_F_tan = 11.11%
bipod_02_F_hex = 11.11%
bipod_02_F_blk = 11.11%
bipod_01_F_snd = 11.11%
bipod_01_F_mtp = 11.11%
bipod_01_F_blk = 11.11%
bipod_01_F_khk = 11.11%
*/
Bipods[] = {"bipod_01_F_blk", "bipod_01_F_snd", "bipod_02_F_tan", "bipod_01_F_mtp", "bipod_02_F_blk", "bipod_03_F_oli", "bipod_02_F_hex", "bipod_03_F_blk", "bipod_01_F_khk"};
/*
Percental Item Spawn Chances of HEGrenades:
3Rnd_HE_Grenade_shell = 25.00%
1Rnd_HE_Grenade_shell = 75.00%
*/
HEGrenades[] = {"1Rnd_HE_Grenade_shell", "1Rnd_HE_Grenade_shell", "1Rnd_HE_Grenade_shell", "3Rnd_HE_Grenade_shell"};
/*
Percental Item Spawn Chances of UGLFlares:
3Rnd_UGL_FlareGreen_F = 6.25%
3Rnd_UGL_FlareRed_F = 6.25%
3Rnd_UGL_FlareWhite_F = 6.25%
3Rnd_UGL_FlareYellow_F = 6.25%
UGL_FlareGreen_F = 18.75%
UGL_FlareRed_F = 18.75%
UGL_FlareWhite_F = 18.75%
UGL_FlareYellow_F = 18.75%
*/
UGLFlares[] = {"UGL_FlareYellow_F", "3Rnd_UGL_FlareYellow_F", "UGL_FlareWhite_F", "3Rnd_UGL_FlareWhite_F", "UGL_FlareGreen_F", "UGL_FlareGreen_F", "UGL_FlareRed_F", "UGL_FlareRed_F", "UGL_FlareGreen_F", "UGL_FlareWhite_F", "3Rnd_UGL_FlareRed_F", "UGL_FlareRed_F", "UGL_FlareYellow_F", "UGL_FlareYellow_F", "UGL_FlareWhite_F", "3Rnd_UGL_FlareGreen_F"};
/*
Percental Item Spawn Chances of UGLSmokes:
3Rnd_Smoke_Grenade_shell = 3.57%
3Rnd_SmokeBlue_Grenade_shell = 3.57%
3Rnd_SmokeGreen_Grenade_shell = 3.57%
3Rnd_SmokeOrange_Grenade_shell = 3.57%
3Rnd_SmokePurple_Grenade_shell = 3.57%
3Rnd_SmokeRed_Grenade_shell = 3.57%
3Rnd_SmokeYellow_Grenade_shell = 3.57%
1Rnd_Smoke_Grenade_shell = 10.71%
1Rnd_SmokeBlue_Grenade_shell = 10.71%
1Rnd_SmokeGreen_Grenade_shell = 10.71%
1Rnd_SmokeOrange_Grenade_shell = 10.71%
1Rnd_SmokePurple_Grenade_shell = 10.71%
1Rnd_SmokeRed_Grenade_shell = 10.71%
1Rnd_SmokeYellow_Grenade_shell = 10.71%
*/
UGLSmokes[] = {"1Rnd_SmokeRed_Grenade_shell", "3Rnd_SmokeBlue_Grenade_shell", "1Rnd_SmokeRed_Grenade_shell", "1Rnd_SmokePurple_Grenade_shell", "3Rnd_SmokePurple_Grenade_shell", "1Rnd_SmokeBlue_Grenade_shell", "1Rnd_SmokeYellow_Grenade_shell", "1Rnd_SmokeRed_Grenade_shell", "1Rnd_SmokeOrange_Grenade_shell", "1Rnd_SmokeOrange_Grenade_shell", "1Rnd_SmokeYellow_Grenade_shell", "1Rnd_SmokeGreen_Grenade_shell", "1Rnd_Smoke_Grenade_shell", "3Rnd_SmokeOrange_Grenade_shell", "3Rnd_Smoke_Grenade_shell", "1Rnd_Smoke_Grenade_shell", "1Rnd_SmokeBlue_Grenade_shell", "1Rnd_SmokeGreen_Grenade_shell", "1Rnd_SmokeOrange_Grenade_shell", "3Rnd_SmokeGreen_Grenade_shell", "3Rnd_SmokeRed_Grenade_shell", "1Rnd_SmokePurple_Grenade_shell", "1Rnd_Smoke_Grenade_shell", "1Rnd_SmokeGreen_Grenade_shell", "1Rnd_SmokeBlue_Grenade_shell", "3Rnd_SmokeYellow_Grenade_shell", "1Rnd_SmokeYellow_Grenade_shell", "1Rnd_SmokePurple_Grenade_shell"};
/*
Percental Item Spawn Chances of HandGrenades:
HandGrenade = 50.00%
MiniGrenade = 50.00%
*/
HandGrenades[] = {"HandGrenade", "MiniGrenade"};
/*
Percental Item Spawn Chances of Explosives:
SatchelCharge_Remote_Mag = 5.26%
APERSBoundingMine_Range_Mag = 15.79%
APERSMine_Range_Mag = 15.79%
APERSTripMine_Wire_Mag = 15.79%
DemoCharge_Remote_Mag = 15.79%
IEDLandSmall_Remote_Mag = 15.79%
IEDUrbanSmall_Remote_Mag = 15.79%
*/
Explosives[] = {"IEDLandSmall_Remote_Mag", "IEDLandSmall_Remote_Mag", "APERSBoundingMine_Range_Mag", "APERSTripMine_Wire_Mag", "APERSMine_Range_Mag", "IEDUrbanSmall_Remote_Mag", "SatchelCharge_Remote_Mag", "APERSMine_Range_Mag", "IEDLandSmall_Remote_Mag", "IEDUrbanSmall_Remote_Mag", "APERSTripMine_Wire_Mag", "IEDUrbanSmall_Remote_Mag", "APERSBoundingMine_Range_Mag", "DemoCharge_Remote_Mag", "DemoCharge_Remote_Mag", "DemoCharge_Remote_Mag", "APERSMine_Range_Mag", "APERSBoundingMine_Range_Mag", "APERSTripMine_Wire_Mag"};
/*
Percental Item Spawn Chances of CivilianItems:
Exile_Item_MobilePhone = 2.78%
Binocular = 11.11%
ItemGPS = 11.11%
ItemRadio = 16.67%
ItemWatch = 16.67%
ItemMap = 19.44%
Exile_Item_Heatpack = 22.22%
*/
CivilianItems[] = {"ItemMap", "ItemGPS", "Exile_Item_Heatpack", "Binocular", "Exile_Item_MobilePhone", "Exile_Item_Heatpack", "ItemMap", "Exile_Item_Heatpack", "ItemGPS", "ItemWatch", "Binocular", "ItemWatch", "ItemWatch", "ItemRadio", "Exile_Item_Heatpack", "Exile_Item_Heatpack", "Exile_Item_Heatpack", "ItemMap", "ItemWatch", "Exile_Item_Heatpack", "ItemGPS", "ItemRadio", "ItemRadio", "ItemRadio", "ItemMap", "ItemMap", "ItemRadio", "Exile_Item_Heatpack", "ItemWatch", "Binocular", "ItemGPS", "ItemMap", "Binocular", "ItemMap", "ItemWatch", "ItemRadio"};
/*
Percental Item Spawn Chances of CivilianClothing:
U_NikosAgedBody = 0.58%
U_NikosBody = 0.58%
U_OrestesBody = 0.58%
U_C_Man_casual_1_F = 2.92%
U_C_Man_casual_2_F = 2.92%
U_C_Man_casual_3_F = 2.92%
U_C_Man_casual_4_F = 2.92%
U_C_Man_casual_5_F = 2.92%
U_C_Man_casual_6_F = 2.92%
U_C_man_sport_1_F = 2.92%
U_C_man_sport_2_F = 2.92%
U_C_man_sport_3_F = 2.92%
U_I_C_Soldier_Bandit_1_F = 2.92%
U_I_C_Soldier_Bandit_2_F = 2.92%
U_I_C_Soldier_Bandit_3_F = 2.92%
U_I_C_Soldier_Bandit_4_F = 2.92%
U_I_C_Soldier_Bandit_5_F = 2.92%
U_C_Poloshirt_blue = 4.09%
U_C_Poloshirt_burgundy = 4.09%
U_C_Poloshirt_salmon = 4.09%
U_C_Poloshirt_stripped = 4.09%
U_C_Poloshirt_tricolour = 4.09%
U_C_HunterBody_grn = 5.26%
U_C_Journalist = 5.26%
U_C_Poor_1 = 5.26%
U_C_Poor_2 = 5.26%
U_C_Poor_shorts_1 = 5.26%
U_C_Scientist = 5.26%
U_Rangemaster = 5.26%
*/
CivilianClothing[] = {"U_C_Poor_1", "U_C_Man_casual_1_F", "U_C_Journalist", "U_C_Man_casual_3_F", "U_I_C_Soldier_Bandit_3_F", "U_I_C_Soldier_Bandit_4_F", "U_C_Poor_1", "U_C_Man_casual_2_F", "U_C_Poloshirt_blue", "U_C_Poloshirt_burgundy", "U_C_Man_casual_1_F", "U_C_Poloshirt_blue", "U_C_Poor_shorts_1", "U_C_Man_casual_6_F", "U_I_C_Soldier_Bandit_2_F", "U_I_C_Soldier_Bandit_5_F", "U_C_man_sport_3_F", "U_C_Journalist", "U_C_Poloshirt_salmon", "U_C_Poloshirt_tricolour", "U_C_Poor_shorts_1", "U_C_Man_casual_3_F", "U_C_Poor_1", "U_OrestesBody", "U_I_C_Soldier_Bandit_5_F", "U_C_Man_casual_5_F", "U_C_Man_casual_5_F", "U_C_Man_casual_6_F", "U_Rangemaster", "U_C_Poor_shorts_1", "U_I_C_Soldier_Bandit_1_F", "U_C_Scientist", "U_I_C_Soldier_Bandit_2_F", "U_I_C_Soldier_Bandit_2_F", "U_C_HunterBody_grn", "U_C_man_sport_2_F", "U_I_C_Soldier_Bandit_5_F", "U_I_C_Soldier_Bandit_2_F", "U_C_man_sport_1_F", "U_C_Man_casual_1_F", "U_C_Man_casual_1_F", "U_C_Poor_shorts_1", "U_C_Poloshirt_salmon", "U_C_Poloshirt_burgundy", "U_I_C_Soldier_Bandit_4_F", "U_C_Man_casual_4_F", "U_C_Poloshirt_salmon", "U_C_Man_casual_6_F", "U_C_Man_casual_2_F", "U_C_Man_casual_3_F", "U_C_Poloshirt_stripped", "U_C_Poor_shorts_1", "U_C_Poloshirt_blue", "U_C_man_sport_2_F", "U_C_HunterBody_grn", "U_C_Man_casual_2_F", "U_Rangemaster", "U_C_Man_casual_2_F", "U_C_Poloshirt_blue", "U_C_Journalist", "U_C_Poloshirt_stripped", "U_C_Poloshirt_salmon", "U_C_Man_casual_3_F", "U_C_HunterBody_grn", "U_C_Poor_1", "U_I_C_Soldier_Bandit_1_F", "U_I_C_Soldier_Bandit_4_F", "U_C_man_sport_3_F", "U_C_Poloshirt_stripped", "U_C_Poloshirt_tricolour", "U_C_Poor_1", "U_C_Scientist", "U_I_C_Soldier_Bandit_1_F", "U_C_Poloshirt_burgundy", "U_C_HunterBody_grn", "U_C_Poloshirt_tricolour", "U_I_C_Soldier_Bandit_4_F", "U_C_Man_casual_3_F", "U_C_HunterBody_grn", "U_C_Scientist", "U_I_C_Soldier_Bandit_5_F", "U_C_Man_casual_6_F", "U_C_Man_casual_4_F", "U_Rangemaster", "U_C_Poor_2", "U_C_Poor_2", "U_I_C_Soldier_Bandit_1_F", "U_C_Poor_2", "U_C_Poor_2", "U_C_Poor_2", "U_C_Poloshirt_stripped", "U_C_Poor_2", "U_C_HunterBody_grn", "U_C_Poloshirt_tricolour", "U_Rangemaster", "U_C_Poloshirt_salmon", "U_C_Poloshirt_blue", "U_C_man_sport_1_F", "U_C_Poloshirt_burgundy", "U_Rangemaster", "U_C_Scientist", "U_C_Man_casual_6_F", "U_C_Poor_2", "U_C_man_sport_3_F", "U_C_Scientist", "U_C_Poloshirt_stripped", "U_C_Poloshirt_tricolour", "U_C_Poloshirt_salmon", "U_NikosAgedBody", "U_C_man_sport_3_F", "U_I_C_Soldier_Bandit_3_F", "U_C_man_sport_1_F", "U_Rangemaster", "U_C_Journalist", "U_I_C_Soldier_Bandit_5_F", "U_C_Poloshirt_stripped", "U_C_Poloshirt_stripped", "U_C_Journalist", "U_C_Man_casual_4_F", "U_C_Poloshirt_burgundy", "U_C_man_sport_3_F", "U_C_Poor_2", "U_NikosBody", "U_C_Poloshirt_salmon", "U_C_HunterBody_grn", "U_C_man_sport_1_F", "U_C_Poor_2", "U_C_Poor_shorts_1", "U_C_Poor_shorts_1", "U_C_HunterBody_grn", "U_C_Poloshirt_tricolour", "U_C_Scientist", "U_I_C_Soldier_Bandit_4_F", "U_I_C_Soldier_Bandit_3_F", "U_C_man_sport_1_F", "U_Rangemaster", "U_C_Man_casual_5_F", "U_C_Man_casual_2_F", "U_C_Scientist", "U_I_C_Soldier_Bandit_3_F", "U_C_Journalist", "U_C_Poor_1", "U_C_Poor_shorts_1", "U_C_Poloshirt_tricolour", "U_C_Man_casual_4_F", "U_C_Journalist", "U_C_man_sport_2_F", "U_C_man_sport_2_F", "U_C_man_sport_2_F", "U_C_Scientist", "U_Rangemaster", "U_C_Poloshirt_burgundy", "U_C_Scientist", "U_I_C_Soldier_Bandit_1_F", "U_C_Man_casual_1_F", "U_C_Journalist", "U_C_Journalist", "U_Rangemaster", "U_C_Poloshirt_burgundy", "U_C_Man_casual_5_F", "U_I_C_Soldier_Bandit_2_F", "U_C_Poor_1", "U_C_Poor_1", "U_C_Poor_1", "U_C_Man_casual_5_F", "U_C_HunterBody_grn", "U_C_Man_casual_4_F", "U_C_Poloshirt_blue", "U_C_Poloshirt_blue", "U_C_Poor_shorts_1", "U_I_C_Soldier_Bandit_3_F"};
/*
Percental Item Spawn Chances of CivilianBackpacks:
B_Kitbag_cbr = 6.67%
B_Kitbag_mcamo = 6.67%
B_Kitbag_sgg = 6.67%
B_AssaultPack_blk = 6.67%
B_AssaultPack_cbr = 6.67%
B_AssaultPack_dgtl = 6.67%
B_AssaultPack_khk = 6.67%
B_AssaultPack_mcamo = 6.67%
B_AssaultPack_rgr = 6.67%
B_AssaultPack_sgg = 6.67%
B_AssaultPack_tna_F = 6.67%
B_HuntingBackpack = 6.67%
B_OutdoorPack_blu = 6.67%
B_OutdoorPack_tan = 6.67%
B_OutdoorPack_blk = 6.67%
*/
CivilianBackpacks[] = {"B_AssaultPack_mcamo", "B_Kitbag_mcamo", "B_OutdoorPack_tan", "B_Kitbag_cbr", "B_AssaultPack_tna_F", "B_AssaultPack_blk", "B_AssaultPack_cbr", "B_OutdoorPack_blk", "B_AssaultPack_khk", "B_Kitbag_sgg", "B_HuntingBackpack", "B_OutdoorPack_blu", "B_AssaultPack_dgtl", "B_AssaultPack_sgg", "B_AssaultPack_rgr"};
/*
Percental Item Spawn Chances of CivilianVests:
V_Press_F = 25.00%
V_TacVest_blk_POLICE = 25.00%
V_Rangemaster_belt = 50.00%
*/
CivilianVests[] = {"V_TacVest_blk_POLICE", "V_Press_F", "V_Rangemaster_belt", "V_Rangemaster_belt"};
/*
Percental Item Spawn Chances of CivilianHeadgear:
H_Bandanna_surfer = 5.56%
H_Beret_blk_POLICE = 5.56%
H_Cap_blk = 5.56%
H_Cap_blk_Raven = 5.56%
H_Cap_blu = 5.56%
H_Cap_grn = 5.56%
H_Cap_headphones = 5.56%
H_Cap_oli = 5.56%
H_Cap_press = 5.56%
H_Cap_red = 5.56%
H_Cap_tan = 5.56%
H_Hat_blue = 5.56%
H_Hat_brown = 5.56%
H_Hat_checker = 5.56%
H_Hat_grey = 5.56%
H_Hat_tan = 5.56%
H_StrawHat = 5.56%
H_StrawHat_dark = 5.56%
*/
CivilianHeadgear[] = {"H_Hat_blue", "H_Beret_blk_POLICE", "H_Hat_checker", "H_Hat_grey", "H_Hat_tan", "H_Cap_blu", "H_Cap_tan", "H_StrawHat", "H_Hat_brown", "H_StrawHat_dark", "H_Cap_blk_Raven", "H_Cap_press", "H_Cap_red", "H_Cap_headphones", "H_Cap_blk", "H_Cap_grn", "H_Cap_oli", "H_Bandanna_surfer"};
/*
Percental Item Spawn Chances of GuerillaItems:
Rangefinder = 6.25%
ItemCompass = 62.50%
NVGoggles = 6.25%
NVGoggles_tna_F = 6.25%
O_NVGoggles_ghex_F = 6.25%
O_NVGoggles_hex_F = 6.25%
O_NVGoggles_urb_F = 6.25%
*/
GuerillaItems[] = {"ItemCompass", "Rangefinder", "NVGoggles_tna_F", "ItemCompass", "O_NVGoggles_urb_F", "ItemCompass", "O_NVGoggles_ghex_F", "ItemCompass", "NVGoggles", "ItemCompass", "ItemCompass", "ItemCompass", "ItemCompass", "ItemCompass", "O_NVGoggles_hex_F", "ItemCompass"};
/*
Percental Item Spawn Chances of GuerillaClothing:
U_I_G_resistanceLeader_F = 1.75%
U_I_C_Soldier_Camo_F = 5.26%
U_I_C_Soldier_Para_1_F = 5.26%
U_I_C_Soldier_Para_2_F = 5.26%
U_I_C_Soldier_Para_3_F = 5.26%
U_I_C_Soldier_Para_4_F = 5.26%
U_I_C_Soldier_Para_5_F = 5.26%
U_IG_leader = 7.02%
U_IG_Guerilla3_1 = 8.77%
U_IG_Guerilla3_2 = 8.77%
U_IG_Guerilla1_1 = 10.53%
U_IG_Guerilla2_1 = 10.53%
U_IG_Guerilla2_2 = 10.53%
U_IG_Guerilla2_3 = 10.53%
*/
GuerillaClothing[] = {"U_IG_Guerilla2_1", "U_IG_Guerilla2_3", "U_I_C_Soldier_Para_4_F", "U_IG_Guerilla1_1", "U_IG_Guerilla2_2", "U_I_C_Soldier_Para_4_F", "U_IG_Guerilla2_2", "U_I_C_Soldier_Para_2_F", "U_IG_Guerilla2_1", "U_I_C_Soldier_Camo_F", "U_IG_Guerilla3_1", "U_IG_leader", "U_IG_Guerilla3_2", "U_IG_Guerilla2_1", "U_IG_Guerilla3_1", "U_IG_Guerilla2_1", "U_IG_Guerilla3_2", "U_I_C_Soldier_Para_1_F", "U_I_C_Soldier_Camo_F", "U_IG_Guerilla3_1", "U_I_C_Soldier_Para_5_F", "U_I_C_Soldier_Para_3_F", "U_I_C_Soldier_Para_5_F", "U_IG_leader", "U_I_C_Soldier_Para_4_F", "U_IG_Guerilla2_3", "U_IG_Guerilla1_1", "U_IG_Guerilla1_1", "U_I_C_Soldier_Camo_F", "U_I_G_resistanceLeader_F", "U_IG_leader", "U_IG_Guerilla2_3", "U_IG_Guerilla3_2", "U_IG_Guerilla3_1", "U_I_C_Soldier_Para_5_F", "U_IG_Guerilla2_1", "U_IG_Guerilla3_2", "U_IG_Guerilla3_1", "U_IG_Guerilla2_3", "U_I_C_Soldier_Para_2_F", "U_IG_Guerilla2_2", "U_IG_Guerilla3_2", "U_IG_Guerilla2_3", "U_I_C_Soldier_Para_3_F", "U_IG_Guerilla2_2", "U_I_C_Soldier_Para_2_F", "U_IG_leader", "U_I_C_Soldier_Para_1_F", "U_IG_Guerilla1_1", "U_IG_Guerilla2_2", "U_I_C_Soldier_Para_1_F", "U_IG_Guerilla1_1", "U_IG_Guerilla2_1", "U_IG_Guerilla1_1", "U_IG_Guerilla2_3", "U_I_C_Soldier_Para_3_F", "U_IG_Guerilla2_2"};
/*
Percental Item Spawn Chances of GuerillaBackpacks:
B_Bergen_blk = 1.82%
B_Bergen_mcamo = 1.82%
B_Bergen_rgr = 1.82%
B_Bergen_sgg = 1.82%
B_FieldPack_ghex_F = 1.82%
B_ViperHarness_base_F = 3.64%
B_ViperHarness_blk_F = 3.64%
B_ViperHarness_ghex_F = 3.64%
B_ViperHarness_hex_F = 3.64%
B_ViperHarness_khk_F = 3.64%
B_ViperHarness_oli_F = 3.64%
B_ViperLightHarness_base_F = 5.45%
B_ViperLightHarness_blk_F = 5.45%
B_ViperLightHarness_ghex_F = 5.45%
B_ViperLightHarness_hex_F = 5.45%
B_ViperLightHarness_khk_F = 5.45%
B_ViperLightHarness_oli_F = 5.45%
B_FieldPack_blk = 9.09%
B_FieldPack_cbr = 9.09%
B_FieldPack_ocamo = 9.09%
B_FieldPack_oucamo = 9.09%
*/
GuerillaBackpacks[] = {"B_ViperHarness_blk_F", "B_ViperLightHarness_base_F", "B_ViperHarness_base_F", "B_ViperHarness_ghex_F", "B_FieldPack_ocamo", "B_FieldPack_blk", "B_ViperLightHarness_khk_F", "B_ViperHarness_ghex_F", "B_FieldPack_ocamo", "B_FieldPack_cbr", "B_ViperLightHarness_ghex_F", "B_FieldPack_ocamo", "B_ViperLightHarness_blk_F", "B_Bergen_blk", "B_ViperLightHarness_oli_F", "B_FieldPack_oucamo", "B_ViperLightHarness_base_F", "B_ViperHarness_khk_F", "B_FieldPack_oucamo", "B_ViperHarness_hex_F", "B_FieldPack_cbr", "B_FieldPack_oucamo", "B_ViperHarness_hex_F", "B_ViperLightHarness_oli_F", "B_FieldPack_oucamo", "B_ViperLightHarness_hex_F", "B_ViperLightHarness_khk_F", "B_Bergen_rgr", "B_FieldPack_ocamo", "B_ViperHarness_oli_F", "B_ViperHarness_base_F", "B_ViperLightHarness_base_F", "B_ViperLightHarness_hex_F", "B_FieldPack_blk", "B_ViperHarness_oli_F", "B_FieldPack_oucamo", "B_ViperLightHarness_ghex_F", "B_ViperLightHarness_hex_F", "B_Bergen_sgg", "B_ViperHarness_blk_F", "B_FieldPack_blk", "B_ViperLightHarness_blk_F", "B_ViperLightHarness_ghex_F", "B_FieldPack_cbr", "B_ViperLightHarness_khk_F", "B_ViperLightHarness_oli_F", "B_Bergen_mcamo", "B_FieldPack_cbr", "B_FieldPack_cbr", "B_FieldPack_ghex_F", "B_FieldPack_ocamo", "B_ViperLightHarness_blk_F", "B_FieldPack_blk", "B_ViperHarness_khk_F", "B_FieldPack_blk"};
/*
Percental Item Spawn Chances of GuerillaVests:
V_I_G_resistanceLeader_F = 3.23%
V_BandollierB_blk = 6.45%
V_BandollierB_cbr = 6.45%
V_BandollierB_khk = 6.45%
V_BandollierB_oli = 6.45%
V_BandollierB_rgr = 6.45%
V_Chestrig_blk = 6.45%
V_Chestrig_khk = 6.45%
V_Chestrig_oli = 6.45%
V_Chestrig_rgr = 6.45%
V_HarnessO_brn = 6.45%
V_HarnessO_gry = 6.45%
V_HarnessOGL_brn = 6.45%
V_HarnessOGL_gry = 6.45%
V_HarnessOSpec_brn = 6.45%
V_HarnessOSpec_gry = 6.45%
*/
GuerillaVests[] = {"V_HarnessO_gry", "V_HarnessOSpec_gry", "V_I_G_resistanceLeader_F", "V_BandollierB_blk", "V_HarnessOGL_brn", "V_HarnessOGL_gry", "V_Chestrig_rgr", "V_BandollierB_rgr", "V_HarnessOGL_brn", "V_BandollierB_cbr", "V_Chestrig_oli", "V_BandollierB_oli", "V_HarnessOSpec_brn", "V_Chestrig_oli", "V_HarnessO_gry", "V_BandollierB_cbr", "V_HarnessOSpec_brn", "V_HarnessOGL_gry", "V_BandollierB_oli", "V_HarnessO_brn", "V_BandollierB_rgr", "V_HarnessO_brn", "V_Chestrig_khk", "V_HarnessOSpec_gry", "V_Chestrig_khk", "V_Chestrig_blk", "V_BandollierB_khk", "V_BandollierB_khk", "V_Chestrig_blk", "V_Chestrig_rgr", "V_BandollierB_blk"};
/*
Percental Item Spawn Chances of GuerillaHeadgear:
H_Beret_02 = 0.82%
H_Beret_blk = 0.82%
H_Beret_brn_SF = 0.82%
H_Beret_Colonel = 0.82%
H_Beret_grn = 0.82%
H_Beret_grn_SF = 0.82%
H_Beret_ocamo = 0.82%
H_Beret_red = 0.82%
H_Booniehat_tna_F = 1.64%
H_Cap_blk_Syndikat_F = 1.64%
H_Cap_grn_Syndikat_F = 1.64%
H_Cap_oli_Syndikat_F = 1.64%
H_Cap_tan_Syndikat_F = 1.64%
H_FakeHeadgear_Syndikat_F = 1.64%
H_MilCap_gen_F = 1.64%
H_MilCap_ghex_F = 1.64%
H_MilCap_tna_F = 1.64%
H_Shemag_khk = 1.64%
H_Shemag_olive = 1.64%
H_Shemag_olive_hs = 1.64%
H_Shemag_tan = 1.64%
H_ShemagOpen_khk = 1.64%
H_ShemagOpen_tan = 1.64%
H_TurbanO_blk = 1.64%
H_Watchcap_camo = 1.64%
H_Watchcap_sgg = 1.64%
H_Bandanna_camo = 2.46%
H_Bandanna_cbr = 2.46%
H_Bandanna_gry = 2.46%
H_Bandanna_khk = 2.46%
H_Bandanna_khk_hs = 2.46%
H_Bandanna_mcamo = 2.46%
H_Bandanna_sgg = 2.46%
H_BandMask_blk = 2.46%
H_Cap_brn_SPECOPS = 2.46%
H_Cap_khaki_specops_UK = 2.46%
H_Cap_tan_specops_US = 2.46%
H_Hat_camo = 2.46%
H_Watchcap_blk = 2.46%
H_Watchcap_khk = 2.46%
Exile_Headgear_GasMask = 3.28%
H_Booniehat_dgtl = 3.28%
H_Booniehat_dirty = 3.28%
H_Booniehat_grn = 3.28%
H_Booniehat_indp = 3.28%
H_Booniehat_khk = 3.28%
H_Booniehat_khk_hs = 3.28%
H_Booniehat_mcamo = 3.28%
H_Booniehat_tan = 3.28%
*/
GuerillaHeadgear[] = {"H_Cap_brn_SPECOPS", "H_Booniehat_indp", "H_Booniehat_tan", "H_Beret_02", "H_Cap_khaki_specops_UK", "H_Booniehat_khk", "H_Shemag_tan", "H_Watchcap_khk", "H_Booniehat_dirty", "H_Booniehat_khk_hs", "H_Bandanna_gry", "H_Bandanna_mcamo", "H_Booniehat_indp", "H_Booniehat_grn", "H_ShemagOpen_khk", "H_TurbanO_blk", "H_Bandanna_sgg", "H_Booniehat_khk_hs", "H_Cap_brn_SPECOPS", "H_ShemagOpen_tan", "H_Hat_camo", "H_MilCap_ghex_F", "H_Watchcap_blk", "H_ShemagOpen_tan", "H_Watchcap_khk", "H_Watchcap_sgg", "H_Bandanna_khk", "H_Beret_grn", "H_FakeHeadgear_Syndikat_F", "H_Cap_grn_Syndikat_F", "H_Bandanna_khk_hs", "H_Booniehat_mcamo", "H_Beret_grn_SF", "H_TurbanO_blk", "H_Cap_tan_Syndikat_F", "H_Booniehat_indp", "H_Bandanna_khk", "H_Beret_ocamo", "H_Booniehat_tna_F", "H_Booniehat_grn", "H_Bandanna_mcamo", "H_Booniehat_khk", "H_Booniehat_khk_hs", "H_Booniehat_khk", "H_Shemag_olive_hs", "H_Booniehat_dirty", "H_Bandanna_mcamo", "H_Shemag_olive", "H_Shemag_olive_hs", "H_Watchcap_blk", "H_Booniehat_mcamo", "H_Booniehat_tan", "H_Booniehat_dgtl", "H_ShemagOpen_khk", "H_Hat_camo", "H_Watchcap_camo", "H_Booniehat_mcamo", "Exile_Headgear_GasMask", "H_Cap_blk_Syndikat_F", "H_Booniehat_khk_hs", "H_Booniehat_dgtl", "H_Cap_tan_specops_US", "Exile_Headgear_GasMask", "H_Bandanna_sgg", "H_Booniehat_grn", "H_MilCap_gen_F", "H_Watchcap_camo", "H_Cap_blk_Syndikat_F", "H_Cap_oli_Syndikat_F", "H_Shemag_olive", "H_Bandanna_cbr", "H_Booniehat_tna_F", "H_Beret_red", "H_Booniehat_mcamo", "H_MilCap_ghex_F", "H_Booniehat_dgtl", "H_Booniehat_dirty", "H_Shemag_khk", "H_Booniehat_khk", "H_BandMask_blk", "H_Cap_tan_specops_US", "H_Cap_grn_Syndikat_F", "H_Bandanna_camo", "H_Cap_oli_Syndikat_F", "H_Booniehat_dgtl", "H_Bandanna_cbr", "H_Cap_khaki_specops_UK", "H_Cap_brn_SPECOPS", "H_Watchcap_khk", "H_BandMask_blk", "Exile_Headgear_GasMask", "H_Bandanna_camo", "H_Booniehat_grn", "H_Shemag_tan", "H_BandMask_blk", "H_Booniehat_indp", "H_Bandanna_sgg", "H_Beret_Colonel", "H_Booniehat_tan", "H_Shemag_khk", "H_Bandanna_khk_hs", "H_Bandanna_khk", "H_Watchcap_blk", "H_FakeHeadgear_Syndikat_F", "H_MilCap_tna_F", "Exile_Headgear_GasMask", "H_Hat_camo", "H_Cap_tan_specops_US", "H_Bandanna_cbr", "H_Bandanna_camo", "H_Bandanna_gry", "H_Watchcap_sgg", "H_Booniehat_dirty", "H_Bandanna_khk_hs", "H_Beret_brn_SF", "H_Cap_tan_Syndikat_F", "H_MilCap_tna_F", "H_Booniehat_tan", "H_Beret_blk", "H_Bandanna_gry", "H_Cap_khaki_specops_UK", "H_MilCap_gen_F"};
/*
Percental Item Spawn Chances of MilitaryClothing:
U_B_Wetsuit = 1.32%
U_I_OfficerUniform = 1.32%
U_I_Wetsuit = 1.32%
U_O_CombatUniform_ocamo = 1.32%
U_O_CombatUniform_oucamo = 1.32%
U_O_OfficerUniform_ocamo = 1.32%
U_O_SpecopsUniform_blk = 1.32%
U_O_SpecopsUniform_ocamo = 1.32%
U_O_V_Soldier_Viper_F = 1.32%
U_O_V_Soldier_Viper_hex_F = 1.32%
U_O_Wetsuit = 1.32%
U_B_SpecopsUniform_sgg = 1.97%
U_B_HeliPilotCoveralls = 2.63%
U_B_PilotCoveralls = 2.63%
U_I_CombatUniform = 2.63%
U_I_CombatUniform_shortsleeve = 2.63%
U_I_CombatUniform_tshirt = 2.63%
U_I_HeliPilotCoveralls = 2.63%
U_I_pilotCoveralls = 2.63%
U_O_PilotCoveralls = 2.63%
U_B_CombatUniform_mcam = 3.29%
U_B_CombatUniform_mcam_tshirt = 3.29%
U_B_CombatUniform_mcam_vest = 3.29%
U_B_CombatUniform_mcam_worn = 3.29%
U_B_CTRG_1 = 3.29%
U_B_CTRG_2 = 3.29%
U_B_CTRG_3 = 3.29%
U_B_CTRG_Soldier_2_F = 3.29%
U_B_CTRG_Soldier_3_F = 3.29%
U_B_CTRG_Soldier_F = 3.29%
U_B_CTRG_Soldier_urb_1_F = 3.29%
U_B_CTRG_Soldier_urb_2_F = 3.29%
U_B_CTRG_Soldier_urb_3_F = 3.29%
U_B_GEN_Commander_F = 3.29%
U_B_GEN_Soldier_F = 3.29%
U_B_T_Soldier_AR_F = 3.29%
U_B_T_Soldier_SL_F = 3.29%
U_O_T_Officer_F = 3.29%
U_O_T_Soldier_F = 3.29%
*/
MilitaryClothing[] = {"U_B_CombatUniform_mcam", "U_O_SpecopsUniform_blk", "U_O_SpecopsUniform_ocamo", "U_B_GEN_Commander_F", "U_I_CombatUniform_shortsleeve", "U_B_CTRG_Soldier_urb_3_F", "U_B_GEN_Soldier_F", "U_O_SpecopsUniform_ocamo", "U_B_GEN_Soldier_F", "U_B_CTRG_1", "U_B_CombatUniform_mcam_worn", "U_O_T_Soldier_F", "U_B_Wetsuit", "U_B_CTRG_Soldier_urb_3_F", "U_O_SpecopsUniform_blk", "U_B_CTRG_Soldier_2_F", "U_B_CTRG_Soldier_urb_2_F", "U_O_V_Soldier_Viper_hex_F", "U_O_V_Soldier_Viper_hex_F", "U_I_CombatUniform_tshirt", "U_B_T_Soldier_AR_F", "U_O_CombatUniform_ocamo", "U_B_CTRG_2", "U_B_CTRG_1", "U_B_CTRG_Soldier_urb_2_F", "U_O_CombatUniform_ocamo", "U_B_CombatUniform_mcam_vest", "U_I_OfficerUniform", "U_B_SpecopsUniform_sgg", "U_B_CTRG_1", "U_B_CTRG_Soldier_urb_1_F", "U_B_CombatUniform_mcam", "U_B_T_Soldier_AR_F", "U_O_PilotCoveralls", "U_B_CTRG_Soldier_urb_1_F", "U_B_CTRG_Soldier_3_F", "U_I_pilotCoveralls", "U_I_Wetsuit", "U_B_CTRG_Soldier_urb_2_F", "U_B_HeliPilotCoveralls", "U_B_CTRG_Soldier_urb_1_F", "U_I_OfficerUniform", "U_B_CTRG_Soldier_urb_1_F", "U_O_V_Soldier_Viper_F", "U_O_T_Officer_F", "U_B_CombatUniform_mcam_vest", "U_B_CTRG_Soldier_3_F", "U_B_CTRG_3", "U_B_CombatUniform_mcam_vest", "U_I_CombatUniform", "U_B_CTRG_3", "U_B_HeliPilotCoveralls", "U_B_CTRG_Soldier_urb_1_F", "U_B_T_Soldier_AR_F", "U_B_CTRG_3", "U_O_OfficerUniform_ocamo", "U_B_CTRG_Soldier_F", "U_B_CombatUniform_mcam_tshirt", "U_O_T_Officer_F", "U_B_T_Soldier_AR_F", "U_B_T_Soldier_SL_F", "U_O_Wetsuit", "U_I_HeliPilotCoveralls", "U_O_PilotCoveralls", "U_B_CTRG_2", "U_I_Wetsuit", "U_I_pilotCoveralls", "U_B_CTRG_Soldier_2_F", "U_B_CTRG_2", "U_B_CTRG_Soldier_3_F", "U_O_CombatUniform_oucamo", "U_O_T_Soldier_F", "U_I_pilotCoveralls", "U_B_T_Soldier_SL_F", "U_O_T_Soldier_F", "U_B_T_Soldier_SL_F", "U_I_CombatUniform_shortsleeve", "U_O_T_Soldier_F", "U_B_CTRG_1", "U_B_CombatUniform_mcam_worn", "U_B_GEN_Soldier_F", "U_B_CombatUniform_mcam_tshirt", "U_I_CombatUniform", "U_O_T_Soldier_F", "U_B_CTRG_Soldier_F", "U_B_CombatUniform_mcam", "U_B_CTRG_3", "U_B_GEN_Soldier_F", "U_B_CTRG_2", "U_B_CTRG_Soldier_3_F", "U_B_CombatUniform_mcam", "U_B_GEN_Commander_F", "U_O_PilotCoveralls", "U_I_CombatUniform_tshirt", "U_B_GEN_Commander_F", "U_O_T_Officer_F", "U_B_PilotCoveralls", "U_B_T_Soldier_SL_F", "U_I_CombatUniform", "U_B_T_Soldier_AR_F", "U_B_GEN_Commander_F", "U_B_PilotCoveralls", "U_B_CTRG_3", "U_B_CombatUniform_mcam_tshirt", "U_B_PilotCoveralls", "U_I_HeliPilotCoveralls", "U_B_SpecopsUniform_sgg", "U_O_T_Officer_F", "U_B_HeliPilotCoveralls", "U_B_CTRG_Soldier_urb_3_F", "U_B_PilotCoveralls", "U_O_Wetsuit", "U_B_CTRG_1", "U_I_HeliPilotCoveralls", "U_B_CTRG_Soldier_2_F", "U_O_V_Soldier_Viper_F", "U_B_CTRG_Soldier_2_F", "U_O_CombatUniform_oucamo", "U_O_T_Officer_F", "U_B_CTRG_2", "U_B_CombatUniform_mcam_worn", "U_B_CTRG_Soldier_F", "U_B_CTRG_Soldier_urb_2_F", "U_I_HeliPilotCoveralls", "U_B_CTRG_Soldier_3_F", "U_O_PilotCoveralls", "U_B_CTRG_Soldier_urb_3_F", "U_B_CTRG_Soldier_urb_2_F", "U_I_CombatUniform_shortsleeve", "U_B_T_Soldier_SL_F", "U_B_CTRG_Soldier_urb_3_F", "U_B_CTRG_Soldier_F", "U_B_SpecopsUniform_sgg", "U_B_CombatUniform_mcam_tshirt", "U_I_CombatUniform_tshirt", "U_B_CombatUniform_mcam_vest", "U_B_GEN_Commander_F", "U_B_HeliPilotCoveralls", "U_B_CTRG_Soldier_2_F", "U_I_CombatUniform_shortsleeve", "U_B_CombatUniform_mcam", "U_O_OfficerUniform_ocamo", "U_I_CombatUniform_tshirt", "U_B_GEN_Soldier_F", "U_B_CombatUniform_mcam_vest", "U_B_CombatUniform_mcam_tshirt", "U_B_Wetsuit", "U_B_CombatUniform_mcam_worn", "U_I_pilotCoveralls", "U_B_CombatUniform_mcam_worn", "U_B_CTRG_Soldier_F", "U_I_CombatUniform"};
/*
Percental Item Spawn Chances of MilitaryBackpacks:
B_Bergen_Base_F = 5.26%
B_Bergen_dgtl_F = 5.26%
B_Bergen_hex_F = 5.26%
B_Bergen_mcamo_F = 5.26%
B_Bergen_tna_F = 5.26%
B_Carryall_mcamo = 10.53%
B_Carryall_ocamo = 10.53%
B_Carryall_oucamo = 10.53%
B_Carryall_khk = 10.53%
B_Carryall_oli = 10.53%
B_Carryall_cbr = 10.53%
B_Carryall_ghex_F = 10.53%
*/
MilitaryBackpacks[] = {"B_Carryall_ghex_F", "B_Bergen_tna_F", "B_Carryall_oucamo", "B_Carryall_mcamo", "B_Carryall_cbr", "B_Carryall_khk", "B_Carryall_mcamo", "B_Carryall_ocamo", "B_Bergen_Base_F", "B_Carryall_ghex_F", "B_Bergen_mcamo_F", "B_Carryall_oli", "B_Carryall_oli", "B_Carryall_khk", "B_Bergen_dgtl_F", "B_Carryall_cbr", "B_Bergen_hex_F", "B_Carryall_ocamo", "B_Carryall_oucamo"};
/*
Percental Item Spawn Chances of MilitaryVests:
V_PlateCarrierH_CTRG = 5.00%
V_PlateCarrierL_CTRG = 5.00%
V_PlateCarrier1_blk = 10.00%
V_PlateCarrier1_rgr = 10.00%
V_PlateCarrier2_rgr = 10.00%
V_PlateCarrier3_rgr = 10.00%
V_PlateCarrierGL_rgr = 10.00%
V_PlateCarrierIA1_dgtl = 10.00%
V_PlateCarrierIA2_dgtl = 10.00%
V_PlateCarrierIAGL_dgtl = 10.00%
V_PlateCarrierSpec_rgr = 10.00%
*/
MilitaryVests[] = {"V_PlateCarrier3_rgr", "V_PlateCarrier1_blk", "V_PlateCarrier2_rgr", "V_PlateCarrier2_rgr", "V_PlateCarrierGL_rgr", "V_PlateCarrierIA1_dgtl", "V_PlateCarrierIAGL_dgtl", "V_PlateCarrierIA1_dgtl", "V_PlateCarrierIA2_dgtl", "V_PlateCarrier1_blk", "V_PlateCarrierGL_rgr", "V_PlateCarrierIA2_dgtl", "V_PlateCarrier1_rgr", "V_PlateCarrierH_CTRG", "V_PlateCarrierSpec_rgr", "V_PlateCarrierSpec_rgr", "V_PlateCarrier1_rgr", "V_PlateCarrier3_rgr", "V_PlateCarrierL_CTRG", "V_PlateCarrierIAGL_dgtl"};
/*
Percental Item Spawn Chances of MilitaryHeadgear:
H_CrewHelmetHeli_B = 0.81%
H_CrewHelmetHeli_I = 0.81%
H_CrewHelmetHeli_O = 0.81%
H_HelmetB_camo = 0.81%
H_HelmetCrew_B = 0.81%
H_HelmetCrew_I = 0.81%
H_HelmetCrew_O = 0.81%
H_HelmetLeaderO_ocamo = 0.81%
H_HelmetLeaderO_oucamo = 0.81%
H_HelmetO_ghex_F = 0.81%
H_HelmetO_ocamo = 0.81%
H_HelmetO_oucamo = 0.81%
H_HelmetSpecO_blk = 0.81%
H_HelmetSpecO_ocamo = 0.81%
H_PilotHelmetFighter_B = 0.81%
H_PilotHelmetFighter_I = 0.81%
H_PilotHelmetFighter_O = 0.81%
H_PilotHelmetHeli_B = 0.81%
H_PilotHelmetHeli_I = 0.81%
H_PilotHelmetHeli_O = 0.81%
H_BandMask_demon = 1.63%
H_BandMask_khk = 1.63%
H_BandMask_reaper = 1.63%
H_Beret_gen_F = 1.63%
H_Helmet_Skate = 1.63%
H_HelmetB_black = 1.63%
H_HelmetB_desert = 1.63%
H_HelmetB_Enh_tna_F = 1.63%
H_HelmetB_grass = 1.63%
H_HelmetB_light_black = 1.63%
H_HelmetB_light_desert = 1.63%
H_HelmetB_light_grass = 1.63%
H_HelmetB_light_sand = 1.63%
H_HelmetB_light_snakeskin = 1.63%
H_HelmetB_Light_tna_F = 1.63%
H_HelmetB_sand = 1.63%
H_HelmetB_snakeskin = 1.63%
H_HelmetB_TI_tna_F = 1.63%
H_HelmetB_tna_F = 1.63%
H_HelmetCrew_O_ghex_F = 1.63%
H_HelmetIA_camo = 1.63%
H_HelmetIA_net = 1.63%
H_HelmetLeaderO_ghex_F = 1.63%
H_HelmetSpecO_ghex_F = 1.63%
H_HelmetB = 2.44%
H_HelmetB_light = 2.44%
H_HelmetB_paint = 2.44%
H_HelmetB_plain_blk = 2.44%
H_HelmetIA = 2.44%
H_HelmetSpecB = 2.44%
H_HelmetSpecB_blk = 2.44%
H_HelmetSpecB_paint1 = 2.44%
H_HelmetSpecB_paint2 = 2.44%
Exile_Headgear_GasMask = 3.25%
H_MilCap_blue = 3.25%
H_MilCap_dgtl = 3.25%
H_MilCap_mcamo = 3.25%
H_MilCap_ocamo = 3.25%
H_MilCap_oucamo = 3.25%
H_MilCap_rucamo = 3.25%
*/
MilitaryHeadgear[] = {"H_BandMask_reaper", "Exile_Headgear_GasMask", "H_HelmetB_light_sand", "H_HelmetSpecB_paint1", "H_MilCap_blue", "H_HelmetB_snakeskin", "H_PilotHelmetFighter_B", "H_HelmetO_ghex_F", "H_HelmetB_plain_blk", "H_HelmetIA", "H_HelmetB_light_black", "H_MilCap_ocamo", "H_MilCap_blue", "H_HelmetB_light", "H_HelmetSpecB", "H_HelmetCrew_O", "H_Helmet_Skate", "H_HelmetB_light_sand", "H_HelmetB_light_grass", "H_HelmetB_Light_tna_F", "H_HelmetB_light_desert", "H_MilCap_rucamo", "H_HelmetLeaderO_oucamo", "Exile_Headgear_GasMask", "H_HelmetLeaderO_ghex_F", "H_MilCap_ocamo", "H_BandMask_demon", "H_PilotHelmetHeli_I", "H_MilCap_blue", "H_MilCap_rucamo", "H_HelmetB_paint", "H_PilotHelmetHeli_B", "H_HelmetIA_camo", "H_MilCap_mcamo", "H_HelmetIA", "H_PilotHelmetFighter_O", "H_HelmetB_light_desert", "H_HelmetB_desert", "H_HelmetB_paint", "H_MilCap_mcamo", "H_MilCap_oucamo", "H_MilCap_rucamo", "H_HelmetLeaderO_ocamo", "H_HelmetB", "H_HelmetSpecO_ghex_F", "H_HelmetIA_net", "H_MilCap_dgtl", "H_HelmetSpecB_blk", "H_HelmetSpecB_blk", "H_HelmetB_camo", "H_HelmetB_light_black", "H_MilCap_mcamo", "H_HelmetSpecB_blk", "H_BandMask_reaper", "H_MilCap_ocamo", "H_HelmetO_oucamo", "H_HelmetB_grass", "H_MilCap_dgtl", "H_BandMask_demon", "H_MilCap_blue", "H_HelmetB_sand", "H_MilCap_oucamo", "H_HelmetSpecO_ocamo", "H_MilCap_mcamo", "H_HelmetB_paint", "H_HelmetIA", "H_BandMask_khk", "H_HelmetSpecB", "H_HelmetB", "H_CrewHelmetHeli_B", "H_HelmetB_black", "H_HelmetB_tna_F", "H_HelmetB_Enh_tna_F", "H_HelmetB_grass", "H_HelmetB_light_snakeskin", "H_HelmetB_sand", "H_MilCap_dgtl", "H_CrewHelmetHeli_O", "H_PilotHelmetFighter_I", "H_HelmetB_desert", "H_HelmetSpecB_paint2", "H_HelmetSpecB", "H_HelmetB_snakeskin", "H_PilotHelmetHeli_O", "H_HelmetSpecB_paint2", "H_HelmetB_light_snakeskin", "H_Helmet_Skate", "H_HelmetB_Light_tna_F", "H_BandMask_khk", "H_Beret_gen_F", "H_HelmetB_light_grass", "H_HelmetB_TI_tna_F", "H_MilCap_rucamo", "H_MilCap_oucamo", "H_HelmetLeaderO_ghex_F", "H_HelmetSpecO_ghex_F", "H_HelmetB_plain_blk", "H_HelmetSpecB_paint1", "H_HelmetB_light", "H_HelmetB", "H_HelmetB_light", "Exile_Headgear_GasMask", "H_MilCap_oucamo", "H_HelmetO_ocamo", "H_HelmetB_black", "H_HelmetB_tna_F", "H_HelmetIA_camo", "Exile_Headgear_GasMask", "H_CrewHelmetHeli_I", "H_HelmetSpecB_paint1", "H_HelmetB_TI_tna_F", "H_HelmetSpecO_blk", "H_MilCap_dgtl", "H_MilCap_ocamo", "H_HelmetB_Enh_tna_F", "H_HelmetCrew_O_ghex_F", "H_HelmetB_plain_blk", "H_HelmetCrew_B", "H_HelmetSpecB_paint2", "H_HelmetIA_net", "H_HelmetCrew_O_ghex_F", "H_HelmetCrew_I", "H_Beret_gen_F"};
/*
Percental Item Spawn Chances of Ghillies:
U_B_GhillieSuit = 33.33%
U_O_GhillieSuit = 33.33%
U_I_GhillieSuit = 33.33%
*/
Ghillies[] = {"U_B_GhillieSuit", "U_O_GhillieSuit", "U_I_GhillieSuit"};
/*
Percental Item Spawn Chances of DLCGhillies:
U_B_FullGhillie_ard = 2.94%
U_B_FullGhillie_lsh = 2.94%
U_B_FullGhillie_sard = 2.94%
U_O_FullGhillie_ard = 2.94%
U_O_FullGhillie_lsh = 2.94%
U_O_FullGhillie_sard = 2.94%
U_I_FullGhillie_ard = 2.94%
U_I_FullGhillie_lsh = 2.94%
U_I_FullGhillie_sard = 2.94%
U_B_T_Sniper_F = 14.71%
U_B_T_Soldier_F = 14.71%
U_B_T_FullGhillie_tna_F = 14.71%
U_O_T_Sniper_F = 14.71%
U_O_T_FullGhillie_tna_F = 14.71%
*/
DLCGhillies[] = {"U_B_T_FullGhillie_tna_F", "U_O_T_FullGhillie_tna_F", "U_B_T_Sniper_F", "U_O_FullGhillie_lsh", "U_B_T_Sniper_F", "U_O_FullGhillie_ard", "U_O_T_FullGhillie_tna_F", "U_O_T_Sniper_F", "U_O_T_Sniper_F", "U_O_T_FullGhillie_tna_F", "U_I_FullGhillie_lsh", "U_B_T_Sniper_F", "U_B_FullGhillie_sard", "U_B_T_Soldier_F", "U_B_T_Soldier_F", "U_O_T_Sniper_F", "U_B_T_Sniper_F", "U_O_T_Sniper_F", "U_B_T_FullGhillie_tna_F", "U_O_FullGhillie_sard", "U_B_T_Soldier_F", "U_O_T_FullGhillie_tna_F", "U_B_T_Soldier_F", "U_O_T_FullGhillie_tna_F", "U_B_T_Soldier_F", "U_I_FullGhillie_ard", "U_B_T_FullGhillie_tna_F", "U_B_T_FullGhillie_tna_F", "U_B_T_FullGhillie_tna_F", "U_B_FullGhillie_lsh", "U_O_T_Sniper_F", "U_B_T_Sniper_F", "U_B_FullGhillie_ard", "U_I_FullGhillie_sard"};
/*
Percental Item Spawn Chances of DLCVests:
V_PlateCarrierGL_blk = 4.76%
V_PlateCarrierGL_mtp = 4.76%
V_PlateCarrierGL_rgr = 4.76%
V_PlateCarrierIAGL_dgtl = 4.76%
V_PlateCarrierIAGL_oli = 4.76%
V_PlateCarrierSpec_blk = 4.76%
V_PlateCarrierSpec_mtp = 4.76%
V_PlateCarrierSpec_rgr = 4.76%
V_TacChestrig_grn_F = 4.76%
V_TacChestrig_oli_F = 4.76%
V_TacChestrig_cbr_F = 4.76%
V_PlateCarrier1_tna_F = 4.76%
V_PlateCarrier2_tna_F = 4.76%
V_PlateCarrierSpec_tna_F = 4.76%
V_PlateCarrierGL_tna_F = 4.76%
V_HarnessO_ghex_F = 4.76%
V_HarnessOGL_ghex_F = 4.76%
V_BandollierB_ghex_F = 4.76%
V_TacVest_gen_F = 4.76%
V_PlateCarrier1_rgr_noflag_F = 4.76%
V_PlateCarrier2_rgr_noflag_F = 4.76%
*/
DLCVests[] = {"V_PlateCarrierIAGL_oli", "V_PlateCarrierGL_tna_F", "V_PlateCarrierGL_mtp", "V_HarnessO_ghex_F", "V_PlateCarrier2_tna_F", "V_HarnessOGL_ghex_F", "V_PlateCarrierSpec_mtp", "V_TacChestrig_grn_F", "V_PlateCarrierGL_blk", "V_PlateCarrierSpec_tna_F", "V_PlateCarrierSpec_rgr", "V_TacChestrig_oli_F", "V_PlateCarrier1_rgr_noflag_F", "V_TacChestrig_cbr_F", "V_PlateCarrier2_rgr_noflag_F", "V_PlateCarrierSpec_blk", "V_PlateCarrierGL_rgr", "V_PlateCarrierIAGL_dgtl", "V_BandollierB_ghex_F", "V_TacVest_gen_F", "V_PlateCarrier1_tna_F"};
/*
Percental Item Spawn Chances of Rebreathers:
V_RebreatherB = 33.33%
V_RebreatherIR = 33.33%
V_RebreatherIA = 33.33%
*/
Rebreathers[] = {"V_RebreatherIA", "V_RebreatherIR", "V_RebreatherB"};
/*
Percental Item Spawn Chances of MedicalItems:
Exile_Item_InstaDoc = 9.09%
Exile_Item_Bandage = 18.18%
Exile_Item_Vishpirin = 36.36%
Exile_Item_Heatpack = 36.36%
*/
MedicalItems[] = {"Exile_Item_Heatpack", "Exile_Item_Vishpirin", "Exile_Item_Bandage", "Exile_Item_Bandage", "Exile_Item_Vishpirin", "Exile_Item_Vishpirin", "Exile_Item_Heatpack", "Exile_Item_Heatpack", "Exile_Item_Vishpirin", "Exile_Item_Heatpack", "Exile_Item_InstaDoc"};
/*
Percental Item Spawn Chances of IndustrialItems:
Exile_Item_ThermalScannerPro = 0.66%
Exile_Item_Knife = 1.32%
Exile_Item_Cement = 1.97%
Exile_Item_FloodLightKit = 1.97%
Exile_Item_PortableGeneratorKit = 1.97%
Exile_Item_CamoTentKit = 2.63%
Exile_Item_MetalBoard = 2.63%
Exile_Item_Foolbox = 2.63%
Exile_Item_Sand = 2.63%
Exile_Item_Grinder = 3.29%
Exile_Item_MetalScrews = 3.29%
Exile_Melee_SledgeHammer = 3.29%
Exile_Item_ExtensionCord = 5.26%
Exile_Item_LightBulb = 5.92%
Exile_Item_WaterCanisterEmpty = 6.58%
Exile_Melee_Shovel = 6.58%
Exile_Item_JunkMetal = 7.24%
Exile_Item_Handsaw = 8.55%
Exile_Item_Pliers = 8.55%
Exile_Item_ScrewDriver = 8.55%
Exile_Melee_Axe = 14.47%
*/
IndustrialItems[] = {"Exile_Item_Pliers", "Exile_Item_Sand", "Exile_Item_Pliers", "Exile_Melee_Shovel", "Exile_Melee_Axe", "Exile_Item_ScrewDriver", "Exile_Melee_SledgeHammer", "Exile_Item_Handsaw", "Exile_Item_JunkMetal", "Exile_Item_Knife", "Exile_Item_ExtensionCord", "Exile_Melee_Axe", "Exile_Melee_Shovel", "Exile_Melee_Axe", "Exile_Item_Handsaw", "Exile_Item_ExtensionCord", "Exile_Item_LightBulb", "Exile_Item_LightBulb", "Exile_Item_JunkMetal", "Exile_Item_Pliers", "Exile_Melee_Axe", "Exile_Item_Handsaw", "Exile_Melee_SledgeHammer", "Exile_Melee_Axe", "Exile_Item_Foolbox", "Exile_Item_ExtensionCord", "Exile_Item_ScrewDriver", "Exile_Item_FloodLightKit", "Exile_Melee_Shovel", "Exile_Melee_Axe", "Exile_Melee_Axe", "Exile_Item_FloodLightKit", "Exile_Item_ExtensionCord", "Exile_Item_ThermalScannerPro", "Exile_Item_MetalScrews", "Exile_Item_CamoTentKit", "Exile_Melee_Axe", "Exile_Item_Handsaw", "Exile_Item_MetalScrews", "Exile_Item_Grinder", "Exile_Item_JunkMetal", "Exile_Item_ScrewDriver", "Exile_Item_ExtensionCord", "Exile_Item_LightBulb", "Exile_Item_Handsaw", "Exile_Item_ScrewDriver", "Exile_Item_Pliers", "Exile_Item_ExtensionCord", "Exile_Item_Sand", "Exile_Item_MetalBoard", "Exile_Item_ScrewDriver", "Exile_Melee_Shovel", "Exile_Item_Handsaw", "Exile_Item_PortableGeneratorKit", "Exile_Item_MetalScrews", "Exile_Melee_SledgeHammer", "Exile_Melee_Axe", "Exile_Item_MetalScrews", "Exile_Item_LightBulb", "Exile_Item_LightBulb", "Exile_Item_ScrewDriver", "Exile_Item_ExtensionCord", "Exile_Melee_Shovel", "Exile_Item_Cement", "Exile_Item_CamoTentKit", "Exile_Item_Grinder", "Exile_Melee_Axe", "Exile_Item_Grinder", "Exile_Melee_Axe", "Exile_Item_JunkMetal", "Exile_Item_WaterCanisterEmpty", "Exile_Item_Handsaw", "Exile_Melee_Axe", "Exile_Item_WaterCanisterEmpty", "Exile_Melee_Axe", "Exile_Item_JunkMetal", "Exile_Item_JunkMetal", "Exile_Melee_Axe", "Exile_Item_WaterCanisterEmpty", "Exile_Item_LightBulb", "Exile_Item_WaterCanisterEmpty", "Exile_Melee_Axe", "Exile_Item_JunkMetal", "Exile_Item_Handsaw", "Exile_Item_ScrewDriver", "Exile_Item_Grinder", "Exile_Item_WaterCanisterEmpty", "Exile_Melee_Shovel", "Exile_Melee_SledgeHammer", "Exile_Item_JunkMetal", "Exile_Item_Foolbox", "Exile_Item_Grinder", "Exile_Item_MetalBoard", "Exile_Item_PortableGeneratorKit", "Exile_Item_LightBulb", "Exile_Melee_SledgeHammer", "Exile_Melee_Axe", "Exile_Item_WaterCanisterEmpty", "Exile_Item_JunkMetal", "Exile_Melee_Axe", "Exile_Item_JunkMetal", "Exile_Item_Handsaw", "Exile_Item_ScrewDriver", "Exile_Melee_Axe", "Exile_Melee_Shovel", "Exile_Item_Foolbox", "Exile_Item_WaterCanisterEmpty", "Exile_Item_Pliers", "Exile_Item_Pliers", "Exile_Item_PortableGeneratorKit", "Exile_Item_Pliers", "Exile_Item_Pliers", "Exile_Item_Pliers", "Exile_Item_Cement", "Exile_Item_Knife", "Exile_Item_WaterCanisterEmpty", "Exile_Item_CamoTentKit", "Exile_Item_WaterCanisterEmpty", "Exile_Item_ScrewDriver", "Exile_Item_FloodLightKit", "Exile_Melee_Axe", "Exile_Item_MetalBoard", "Exile_Item_JunkMetal", "Exile_Item_Sand", "Exile_Item_LightBulb", "Exile_Melee_Shovel", "Exile_Item_MetalBoard", "Exile_Item_Pliers", "Exile_Item_Pliers", "Exile_Melee_Axe", "Exile_Item_ScrewDriver", "Exile_Item_MetalScrews", "Exile_Item_Pliers", "Exile_Item_Handsaw", "Exile_Item_Handsaw", "Exile_Item_Pliers", "Exile_Item_ScrewDriver", "Exile_Item_CamoTentKit", "Exile_Item_ScrewDriver", "Exile_Melee_Shovel", "Exile_Item_LightBulb", "Exile_Item_Handsaw", "Exile_Item_Cement", "Exile_Item_Sand", "Exile_Item_WaterCanisterEmpty", "Exile_Item_Handsaw", "Exile_Item_ScrewDriver", "Exile_Item_ExtensionCord", "Exile_Melee_Axe", "Exile_Melee_Shovel", "Exile_Melee_Axe", "Exile_Item_Foolbox"};
/*
Percental Item Spawn Chances of Vehicle:
Exile_Item_FuelCanisterFull = 40.00%
Exile_Item_FuelCanisterEmpty = 50.00%
Exile_Item_DuctTape = 10.00%
*/
Vehicle[] = {"Exile_Item_FuelCanisterFull", "Exile_Item_FuelCanisterEmpty", "Exile_Item_FuelCanisterEmpty", "Exile_Item_FuelCanisterEmpty", "Exile_Item_FuelCanisterFull", "Exile_Item_FuelCanisterFull", "Exile_Item_FuelCanisterFull", "Exile_Item_DuctTape", "Exile_Item_FuelCanisterEmpty", "Exile_Item_FuelCanisterEmpty"};
/*
Percental Item Spawn Chances of Chemlights:
Chemlight_blue = 25.00%
Chemlight_green = 25.00%
Chemlight_red = 25.00%
Chemlight_yellow = 25.00%
*/
Chemlights[] = {"Chemlight_yellow", "Chemlight_blue", "Chemlight_green", "Chemlight_red"};
/*
Percental Item Spawn Chances of RoadFlares:
FlareGreen_F = 25.00%
FlareRed_F = 25.00%
FlareWhite_F = 25.00%
FlareYellow_F = 25.00%
*/
RoadFlares[] = {"FlareRed_F", "FlareGreen_F", "FlareWhite_F", "FlareYellow_F"};
/*
Percental Item Spawn Chances of SmokeGrenades:
SmokeShell = 14.29%
SmokeShellRed = 14.29%
SmokeShellGreen = 14.29%
SmokeShellYellow = 14.29%
SmokeShellPurple = 14.29%
SmokeShellBlue = 14.29%
SmokeShellOrange = 14.29%
*/
SmokeGrenades[] = {"SmokeShellBlue", "SmokeShell", "SmokeShellOrange", "SmokeShellGreen", "SmokeShellPurple", "SmokeShellRed", "SmokeShellYellow"};
/*
Percental Item Spawn Chances of Restraints:
Exile_Item_ZipTie = 100.00%
*/
Restraints[] = {"Exile_Item_ZipTie"};
/*
Percental Item Spawn Chances of Electronics:
Exile_Item_Laptop = 50.00%
Exile_Item_BaseCameraKit = 50.00%
*/
Electronics[] = {"Exile_Item_BaseCameraKit", "Exile_Item_Laptop"};
/*
Percental Item Spawn Chances of Trash:
Exile_Item_Magazine01 = 6.25%
Exile_Item_Magazine02 = 6.25%
Exile_Item_Magazine03 = 6.25%
Exile_Item_Magazine04 = 6.25%
Exile_Item_Can_Empty = 25.00%
Exile_Item_PlasticBottleEmpty = 25.00%
Exile_Item_ToiletPaper = 25.00%
*/
Trash[] = {"Exile_Item_PlasticBottleEmpty", "Exile_Item_Magazine03", "Exile_Item_ToiletPaper", "Exile_Item_Can_Empty", "Exile_Item_Magazine04", "Exile_Item_ToiletPaper", "Exile_Item_PlasticBottleEmpty", "Exile_Item_Can_Empty", "Exile_Item_PlasticBottleEmpty", "Exile_Item_ToiletPaper", "Exile_Item_ToiletPaper", "Exile_Item_Magazine02", "Exile_Item_PlasticBottleEmpty", "Exile_Item_Can_Empty", "Exile_Item_Can_Empty", "Exile_Item_Magazine01"};
/*
Percental Item Spawn Chances of Unused:
Exile_Item_CordlessScrewdriver = 11.11%
Exile_Item_FireExtinguisher = 11.11%
Exile_Item_Rope = 11.11%
Exile_Item_Carwheel = 11.11%
Exile_Item_Defibrillator = 11.11%
Exile_Item_SleepingMat = 11.11%
Exile_Item_Wrench = 11.11%
Exile_Item_OilCanister = 11.11%
Exile_Item_Hammer = 11.11%
*/
Unused[] = {"Exile_Item_Hammer", "Exile_Item_Carwheel", "Exile_Item_OilCanister", "Exile_Item_Rope", "Exile_Item_CordlessScrewdriver", "Exile_Item_FireExtinguisher", "Exile_Item_Wrench", "Exile_Item_SleepingMat", "Exile_Item_Defibrillator"};
};
};
class CfgSettings
{
///////////////////////////////////////////////////////////////////////
// Community Base Addons
///////////////////////////////////////////////////////////////////////
class CBA
{
// Set this to 1 if you want to have CBA support
useStackedEH = 0;
// If you set this to 1 ...........................................
iReallyWantToGetHackedAndImRetarded = 0;
};
///////////////////////////////////////////////////////////////////////
// GARBAGE COLLECTOR
///////////////////////////////////////////////////////////////////////
class GarbageCollector
{
/*
Remark:
In 0.9.35 and below, Exile has checked if a player was nearby and then delayed
the deletion. This check has been removed to save server performance.
Do NOT touch these if you are not 10000% sure what you do!
*/
class Ingame
{
// Dropped items without fissix
class GroundWeaponHolder
{
lifeTime = 15;
interval = 10;
};
// Dropped items with fissix
class WeaponHolderSimulated
{
lifeTime = 15;
interval = 10;
};
// Corpses and wrecks
class AllDead
{
lifeTime = 20;
interval = 15;
};
// Loot spawned inside a building
class Loot
{
lifeTime = 16;
interval = 2;
};
// Never touch this or you will break your sever!
class Groups
{
interval = 0.5;
};
};
class Database
{
// Remove all deleted items from the database after X days
permanentlyDeleteTime = 21;
// Remove all territories (and contructions + containers in it) that were not paid after X days
territoryLifeTime = 14;
// Remove all containers outside of territories that have not been used for X days
// Example: Tents
containerLifeTime = 14;
// Remove all constructions outside of territories that are older than X days or not moved for X days
// Example: Work Benches
constructionLifeTime = 7;
// Remove all vehicles that were not moved/used for X days
vehicleLifeTime = 14;
// Set safe as abandoned
abandonedTime = 14;
// Deletes a base X days after the flag is stolen if the ransom money isn't paid
stolenFlagLifeTime = 5;
// Sets door & safe pins to 0000 and marks safes to abandoned X days after the flag is stolen if the ransom money isn't paid
unlockLifeTime = 14;
};
};
///////////////////////////////////////////////////////////////////////
// RESPECT, YO
///////////////////////////////////////////////////////////////////////
class Respect
{
/**
* Defines the factor of respect you gain for every pop tab in revenue
*
* Default: Get 1 respect for every 10 pop tabs
*/
tradingRespectFactor = 0.2;
/**
* Defines the the minimum amount of Respect earned/lost for a kill
*/
minRespectTransfer = 50;
/**
* Defines the amount of respect earned/lost for certain types of frags
*/
class Frags
{
domination = 80; // Keeps killing the same guy
letItRain = 150; // MG, also vehicle MGs
humiliation = 300; // Axe
passenger = 400; // Out of car/chopper/boat
roadKill = 200; // :)
bigBird = 600; // Roadkill, but with chopper/plane
chuteGreaterChopper = 1000; // Someone flies into chute and chopper/plane explodes
};
class Percentages
{
unlucky = 1; // Dying for an unknown reason costs you 1% respect
crash = 1; // Crashing your car costs you 1% respect
suicide = 2; // Comitting suicide costs you 2% of your respect
friendyFire = 3; // Friendly fire costs you 3%
npc = 4; // Being killed by an NPC costs you 4%
bambiKill = 5; // Killing a bambi costs you 5%
frag = 5; // Killing someone will get you 5% and remove 5% from the victim
};
class Handcuffs
{
trapping = -50; // A handcuffs B
breakingFree = 100; // B broke free
releasedByHero = 100; // C releases B
releasedByHostageTaker = 50; // A releases B
};
class Bonus
{
// Bonus per full 100m
per100mDistance = 10;
// First blood after server restart
firstBlood = 100;
// If you kill someone while you are in your own territory
homie = 20;
// If you kill someone who is in his own territory
raid = 20;
/*
Example with killstreak = 50
Frag Factor Bonus
2 * 50 +100
3 * 50 +150
4 * 50 +200
5 * 50 +250
*/
killStreak = 50;
// Kills within this amount of seconds stack (default: 2 minutes)
killStreakTimeout = 120;
};
};
///////////////////////////////////////////////////////////////////////
// KILLFEED MAN!
///////////////////////////////////////////////////////////////////////
class KillFeed
{
// Shows a kill feed for well kills
showKillFeed = 1;
};
///////////////////////////////////////////////////////////////////////
// PLAYER SPAWN CONFIGURATION
///////////////////////////////////////////////////////////////////////
class BambiSettings
{
/**
* Loadout of new bambi players
*
* (They will always spawn with a bambi overall - you cannot
* change the loadout uniform)
*/
loadOut[] =
{
"ItemCompass",
"ItemMap", // Because why not
"Exile_Item_XM8",
"ItemRadio",
"Exile_Item_PlasticBottleFreshWater",
"hgun_Pistol_heavy_01_F",
"optic_MRD",
"11Rnd_45ACP_Mag",
"11Rnd_45ACP_Mag"
};
/**
* Enables or disables parachute spawning.
*
* 1 = On
* 0 = Off
*/
parachuteSpawning = 1;
/**
* Enables or disables halo jumping. Only applies
* if parachute spawning is enabled.
*
* Remember that if you enable halo jump, it is adviced
* to adjust the parachuteDropHeight to something around
* 1km or so.
*
* 1 = On
* 0 = Off
*/
haloJump = 1;
/**
* Parachute drop height in meters.
*/
parachuteDropHeight = 1000;
/**
* Number of minutes where a fresh spawned player remains in the
* bambi state. It will end the bambi state after this timeout
* expired or when they pick up their first weapon. Whatever
* happens first.
*/
protectionDuration = 5;
/**
* Radius of spawn zones around the center of spawn zone markers.
*/
spawnZoneRadius = 500;
/**
* These vehicles spawn on server restart close to spawn zones.
* They are non-persistent and will despawn on server restart.
* Basically they are just used to get away from the spawn zone
* faster.
*
* {Number of vehicles *per* spawn zone, vehicle class name}
*/
spawnZoneVehicles[] =
{
{2, "Exile_Bike_QuadBike_Blue"}
};
};
///////////////////////////////////////////////////////////////////////
// VEHICLE SPAWN CONFIGURATION
///////////////////////////////////////////////////////////////////////
class VehicleSpawn
{
/**
* Grid Size for vehicle spawning,
* smaller the number more vehicles,
* you get the point
*/
vehiclesGridSize = 4000;
/**
* Vehicle ammount per grid
* kinda self explanitory
*/
vehiclesGridAmount = 1;
/**
* Creates global markers for vehicle spawn tweeking,
* after you are satisfied with vehicle ammount and spread set this to 0.
*/
vehiclesDebugMarkers = 0;
/**
* The server will apply random damage up to this value when spawning a vehicle.
*/
damageChance = 20; // 20% chance for a vehicle HITPOINT to be damaged
maximumDamage = 0.4;
/**
* If "randmizeFuel" is set to 1, vehicles will spawn with randomized
* fuel. In this case, "fuel" controls the percentage of fuel that
* can be in the vehicle at a maximum. For example, if you set this to
* 0.5, then vehicles will spawn with something random between 0% and 50%.
*
* If "randomizeFuel" is set to 0, all vehicles will spawn exactly the
* fuel percentage defined in "fuel". For example, setting this to 0.5
* will spawn all vehicles with 50% fuel. Setting it to 0 would spawn
* all vehicles without fuel.
*/
randomizeFuel = 1;
fuel = 1;
/**
* Works exactly the same as the fuel setting ^
*/
randomizeAmmo = 1;
ammo = 1;
// Stuff to spawn on water
water[] =
{
"Exile_Boat_MotorBoat_Police",
"Exile_Boat_MotorBoat_Orange",
"Exile_Boat_MotorBoat_White",
"Exile_Boat_RubberDuck_CSAT",
"Exile_Boat_RubberDuck_Digital",
"Exile_Boat_RubberDuck_Orange",
"Exile_Boat_RubberDuck_Blue",
"Exile_Boat_RubberDuck_Black",
"Exile_Boat_SDV_CSAT",
"Exile_Boat_SDV_Digital",
"Exile_Boat_SDV_Grey"
};
// Stuff to spawn on roads
ground[] =
{
"CUP_B_LR_Transport_CZ_D",
"Exile_Car_V3S_Covered",
"Exile_Car_SUVXL_Black",
"Exile_Car_Hunter",
"Exile_Car_Ifrit",
"CUP_C_Golf4_camo_Civ",
"Exile_Chopper_Hummingbird_Civillian_Wasp",
"Exile_Chopper_Orca_BlackCustom",
"Exile_Chopper_Hummingbird_Green"
};
/**
* Enables or disables nightvision optics on ALL vehicles
*
* 0 = off
* 1 = on
*/
nightVision = 1;
/**
* Enables or disables thermal optics on ALL vehicles
*
* 0 = off
* 1 = on
*/
thermalVision = 1;
/**
* Set this to 1 to unlock vehicles on server boot if they are in safe zones
*
* 0 = off
* 1 = on
*/
unlockInSafeZonesAfterRestart = 1;
};
class Weather
{
/*
You can define multiple "keyframes" for the weather to change. The server will pick
a keyframe randomly to simulate the weather. It will change the weather-keyframes
based on the following interval
*/
interval = 45;
/*
Add the keyframes here. The server will pick one random, so if you want one
weather type of be more dominant compared to others, add it multiple times
*/
//keyframes[] = {"Sunny", "Cloudy", "Thunderstorm"};
keyframes[] = {"Sunny", "Cloudy", "Thunderstorm"};
/*
This is a keyframe. Look up the BIKI to get more details about the parameters
Be sure to design the fog settings at a view distance of 1,600m as this is the
limit in multiplayer by default
https://community.bistudio.com/wiki/fogParams
https://community.bistudio.com/wiki/overcast
https://community.bistudio.com/wiki/setWaves
https://community.bistudio.com/wiki/setWindStr
https://community.bistudio.com/wiki/setGusts
https://community.bistudio.com/wiki/setRain
https://community.bistudio.com/wiki/setLightnings
https://community.bistudio.com/wiki/setRainbow
*/
class Sunny
{
fogValue = 0;
fogDecay = 0.2;
fogBase = 0;
overcast = 0;
waves = 0.2;
wind = 0.25;
gusts = 0.1;
rain = 0;
lightnings = 0;
rainbows = 0;
};
class Cloudy
{
fogValue = 0;
fogDecay = 0.1;
fogBase = 0;
overcast = 0.4;
waves = 0.4;
wind = 0.25;
gusts = 0.5;
rain = 0.1;
lightnings = 0.1;
rainbows = 1;
};
class Thunderstorm
{
fogValue = 0;
fogDecay = 0.2;
fogBase = 0;
overcast = 1;
waves = 1;
wind = 0.25;
gusts = 0.5;
rain = 1;
lightnings = 1;
rainbows = 0.5;
};
};
class Time
{
// Uses Dedicated Server time as ingame Time
useRealTime = 0;
// Will overide RealTime
useStaticTime = 1;
// time in ARMA FORMAT << CONFIG
// https://community.bistudio.com/wiki/setDate
staticTime[] = {2039,13,30,14,00};
};
class RCON
{
/*
Note that for this to work you need to have serverCommandPassowrd defined in config.cfg and BE enabled
*/
// This needs to match config.cfg serverCommandPassword
serverPassword = "aussiebattlers";
// Autolocks server until its ready to accept players
useAutoLock = 0;
// Server will autoLock at that time before restart (minutes)
restartAutoLock = 3;
/*
Number of hours and minutes of your restart period.
Examples:
{4, 0} = Every 4 hours
{1, 30} = Every one and a half hour (who the hell would do this?)
*/
restartTimer[] = {6, 0};
/*
Kicks players before restart to prevent gear loss.
We strongely recommend to use this!
0 = off
1 = on
*/
useAutoKick = 0;
/*
Number of minutes before the server kicks players that did
not disconnect before the restart. Should at least be two
minutes!
*/
kickTime = 2;
/*
Self-explanatory
0 = off
1 = on
*/
useRestartMessages = 1;
/*
Number of minutes before the restart to inform your players.
Only use full minutes here. Value like 5.5 have not been tested.
*/
restartWarningTime[] = {45,30,20,15,10,5,4,3,2,1};
/*
If set to 1 server will execute '#shutdown',
to try to shutdown the server.
If set to 0, it will execute '#restart'
*/
useShutdown = 0;
};
class ServerSettings
{
/*
Support for custom server FSM if wanted
*/
serverFSM = "exile_server\fsm\main.fsm";
/*
If this is enabled, Exile developers will spawn with a ton of pop tabs.
We will have a hard time debugging things if you disable this.
*/
devFriendyMode = 0;
devs[] =
{
{"76561197985241690","[EXILE|DEV] Eichi"},
{"76561198022879703","[EXILE|DEV] Grim"},
{"76561198075905447","[EXILE|DEV] Vishpala"},
{"76561197968613061","[EXILE|DEV] Niuva"},
{"76561198027700602","[EXILE|DEV] Eraser1"},
{"76561198048317094","[EXILE|DEV] HappyDayZ"},
{"76561198105900802","[EXILE|DEV] Psycho"},
{"76561198004111275","[EXILE|DEV] Maca134"},
{"76561198037177305","[EXILE|DEV] Wolfkill"}
};
};
class Events
{
/*
A list of events that are active
*/
enabledEvents[] = {"AmbientFlyOver", "AbandonedSafe", "EarthQuake", "SupplyBox"};
enabledEscapeEvents[] = {"EscapeSupplyBox", "AmbientFlyOver", "EarthQuake"};
class EarthQuake
{
type = "spawn";
function = "ExileServer_system_event_earthQuake_start";
minTime = 60;
maxTime = 180;
minimumPlayersOnline = 100;
};
class SupplyBox
{
/*
Drops a supply box on a parachute next to a random airport on the map.
The box may contain items. The box can be transported to a territory
and installed to become a normal storage container.
*/
type = "spawn";
function = "ExileServer_system_event_supplyBox_start";
minTime = 60; // minutes
maxTime = 180; // minutes
minimumPlayersOnline = 1;
dropRadius = 500; // 500m around an airport (including the main airport on Altis!)
dropAltitude = 100; // altitude of the drop
markerTime = 10; // minutes
/*
These are different types of boxes can be dropped.
You can specify the cargo a box should contain.
The type of box is chosen randomly from the following list.
Add a type multiple times to increase the chance of being used.
*/
types[] = {"Beer", "Food"};
class BoxTypes
{
class Beer
{
items[] =
{
{"Exile_Item_Beer", 134}
};
};
class Food
{
items[] =
{
{"Exile_Item_BBQSandwich", 5},
{"Exile_Item_Catfood", 5},
{"Exile_Item_ChristmasTinner", 5},
{"Exile_Item_GloriousKnakworst", 5},
{"Exile_Item_SausageGravy", 5},
{"Exile_Item_Surstromming", 5},
{"Exile_Item_CanOpener", 1},
{"Exile_Item_CookingPot", 1},
{"Exile_Item_Matches", 1}
};
};
};
};
class EscapeSupplyBox
{
/*
Drops a supply box on a parachute next to a random airport on the map.
The box may contain items. The box can be transported to a territory
and installed to become a normal storage container.
*/
type = "spawn";
function = "ExileServer_system_event_escapeSupplyBox_start";
minTime = 3; // minutes
maxTime = 6; // minutes
minimumPlayersOnline = 1;
dropAltitude = 100; // altitude of the drop
markerTime = 5; // minutes
/*
These are different types of boxes can be dropped.
You can specify the cargo a box should contain.
The type of box is chosen randomly from the following list.
Add a type multiple times to increase the chance of being used.
*/
types[] = {"CyrusBulletCam","LynxBulletCam","LRRBulletCam","MAR10BulletCam","Rahim","MkIEMR","ASP1Kir","Mk14","CMR","EBR","MXSW","Mk200"};
class BoxTypes
{
class CyrusBulletCam
{
items[] =
{
{"Exile_Magazine_10Rnd_93x64_DMR_05_Bullet_Cam_Mag", 5},
{"10Rnd_93x64_DMR_05_Mag", 5},
{"srifle_DMR_05_blk_F", 1}
};
};
class LynxBulletCam
{
items[] =
{
{"Exile_Magazine_5Rnd_127x108_Bullet_Cam_Mag", 5},
{"5Rnd_127x108_Mag", 5},
{"srifle_GM6_F", 1}
};
};
class LRRBulletCam
{
items[] =
{
{"Exile_Magazine_7Rnd_408_Bullet_Cam_Mag", 5},
{"7Rnd_408_Mag", 5},
{"srifle_LRR_F", 1}
};
};
class MAR10BulletCam
{
items[] =
{
{"Exile_Magazine_10Rnd_338_Bullet_Cam_Mag", 5},
{"10Rnd_338_Mag", 5},
{"srifle_DMR_02_F", 1}
};
};
class Rahim
{
items[] =
{
{"srifle_DMR_01_F", 1},
{"10Rnd_762x54_Mag", 5}
};
};
class MkIEMR
{
items[] =
{
{"srifle_DMR_03_woodland_F", 1},
{"20Rnd_762x51_Mag", 5}
};
};
class ASP1Kir
{
items[] =
{
{"srifle_DMR_04_F", 1},
{"10Rnd_127x54_Mag", 5}
};
};
class Mk14
{
items[] =
{
{"srifle_DMR_06_camo_F", 1},
{"20Rnd_762x51_Mag", 5}
};
};
class CMR
{
items[] =
{
{"srifle_DMR_07_ghex_F", 1},
{"20Rnd_650x39_Cased_Mag_F", 5}
};
};
class EBR
{
items[] =
{
{"srifle_EBR_F", 1},
{"20Rnd_762x51_Mag", 5}
};
};
class MXSW
{
items[] =
{
{"arifle_MX_SW_Black_F", 1},
{"30Rnd_65x39_caseless_mag", 5}
};
};
class Mk200
{
items[] =
{
{"LMG_Mk200_F", 1},
{"200Rnd_65x39_cased_Box", 5}
};
};
};
};
class AbandonedSafe
{
type = "spawn";
function = "ExileServer_system_event_abandonedSafe_start";
minTime = 60; // minutes
maxTime = 120; // minutes
minimumPlayersOnline = 1;
markerTime = 15; // minutes
};
class AmbientFlyOver
{
type = "call";
function = "ExileServer_system_event_ambientFlyOver_start";
minTime = 30; // minutes
maxTime = 90; // minutes
minimumPlayersOnline = 1;
};
};
class Logging
{
/*
If logging is enabled separate logs will be made in the sql logs folder for each type
*/
traderLogging = 1;
deathLogging = 1;
territoryLogging = 1;
};
///////////////////////////////////////////////////////////////////////
// EXILE ESCAPE CONFIGURATION
// NOTE: REQUIRES ExileEscape.MAPNAME MISSION FILE TO BE LOADED!
///////////////////////////////////////////////////////////////////////
class Escape
{
/*
A very simple option with powerful consequences
Set to 1 to enable Exile Escape!
*/
enableEscape = 0;
/*
Map Configs
*/
class Tanoa
{
//Starting Position and radius
startingLocation[] = {1277.18,560.44,0.00142193};
startingAreaRadius = 100;
};
class Altis
{
//Starting Position and radius
startingLocation[] = {8452.87, 25086.9, 0};
startingAreaRadius = 200;
};
// Which players are allowed to spectate after they are dead.
// Useful for admins/mods and streamers
spectatorUIDs[] =
{
"76561197985241690", // Eichi
"76561198022879703", // Grim
"76561198075905447", // Vish
"76561198037177305" // WolfkillArcadia
};
//Number of players needed before the game initializes
minimumPlayersOnline = 10;
//Radius of the circle for each round
roundZoneRadius[] = {1000, 500, 250};
//Final shrink size of last round. To prevent shrinking make finalZoneRadius equal to last roundZoneRadius
finalZoneRadius = 100;
//Time in minutes after minimumPlayersOnline met before game begins
timeBeforeStart = 5;
//Total Round Minutes
minutesPerRound = 10;
//Minutes after round starts before new preview
minutesBeforePreview = 7;
// How much do ppl get when they win?
respectWinKill = 1000;
respectWinGetIn = 500;
respectWinSuicide = 500;
//Number of weapon boxes to spawn
numberOfBoxes = 10;
};
}; | [
"noreply@github.com"
] | noreply@github.com |
1e8448af530cd46fa2629af70633f28a2f452e4c | 6f2b6e9d77fc4dd5e1dae8ba6e5a66eb7c7ae849 | /sstd_boost/sstd/libs/python/test/as_to_python_function.cpp | 0180a73d4adcb4a93d859a8b284121a3e1e4aba4 | [
"BSL-1.0"
] | permissive | KqSMea8/sstd_library | 9e4e622e1b01bed5de7322c2682539400d13dd58 | 0fcb815f50d538517e70a788914da7fbbe786ce1 | refs/heads/master | 2020-05-03T21:07:01.650034 | 2019-04-01T00:10:47 | 2019-04-01T00:10:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 427 | cpp | // Copyright David Abrahams 2002.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <sstd/boost/python/converter/as_to_python_function.hpp>
struct hopefully_illegal
{
static PyObject* convert(int&);
};
PyObject* x = boost::python::converter::as_to_python_function<int, hopefully_illegal>::convert(0);
| [
"zhaixueqiang@hotmail.com"
] | zhaixueqiang@hotmail.com |
541fb06e3a1055c581e056a3456b1cfba5e1c40a | fa82a6fe381ebf75f3b107d8d53bb25e3821f5b8 | /engine3d/cpp/ed3_physics_shapes.cpp | 572a31f233c194176f6fb0b70dc4fa65623bacb2 | [] | no_license | motriuc/sasha-noob-engine | 30a005b2c45cdfe41124cd6bfc93447c31e2760d | 91266dda425f533667568bca4eba7315daa357ed | refs/heads/master | 2016-09-06T14:36:58.961996 | 2013-11-02T20:54:03 | 2013-11-02T20:54:03 | 33,181,907 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,222 | cpp | ////////////////////////////////////////////////////////////////////////
// File Name : ed3_physics_shapes.cpp
// Created : 20 1 2012 19:09
// Author : Alexandru Motriuc
// File Path : SLibF\engine3d\include
// System independent : 0%
// Library :
//
// Purpose:
//
//
/////////////////////////////////////////////////////////////////////////
// Modification History :
//
/////////////////////////////////////////////////////////////////////////
#include "ed3afx.h"
#include "ed3_physics_shapes.h"
#ifdef ED3_ENGINE_USE_PHYSICS
namespace Ed3
{
AUTO_REGISTER_PH_SHAPE_FACTORY( _S("static.plane"), phStaticPlane )
AUTO_REGISTER_PH_SHAPE_FACTORY( _S("sphere"), phSphere )
//----------------------------------------------------------------------
inline void getTransformation( btRigidBody* pRigidBody, d3Matrix& m )
{
const btTransform& tran = pRigidBody->getCenterOfMassTransform();
tran.getOpenGLMatrix( m.v );
}
/***********************************************************************/
/* phStaticPlahe */
/***********************************************************************/
//----------------------------------------------------------------------
phRigidBodyShape::phRigidBodyShape( d3Object* owner ) :
_BaseClass( owner ),
_rigidBody( NULL ),
_shape( NULL )
{
}
//----------------------------------------------------------------------
phRigidBodyShape::~phRigidBodyShape()
{
delete _shape;
delete _rigidBody;
}
//----------------------------------------------------------------------
void phRigidBodyShape::SetScaling( const d3Vector& scaling )
{
__S_ASSERT( _shape != NULL );
_shape->setLocalScaling( btVector3( scaling.x, scaling.y, scaling.z ));
}
//----------------------------------------------------------------------
void phRigidBodyShape::Move( const d3Vector& v )
{
__S_ASSERT( _rigidBody != NULL );
_rigidBody->translate( btVector3( v.x, v.y, v.z ) );
}
//----------------------------------------------------------------------
void phRigidBodyShape::GetTransformation( d3Matrix& transformation )
{
__S_ASSERT( _rigidBody != NULL );
__S_ASSERT( _shape != NULL );
d3Matrix m;
getTransformation( _rigidBody, m );
const btVector3& v = _shape->getLocalScaling();
transformation.SetScale( v.getX(), v.getY(), v.getZ() );
transformation *= m;
}
//----------------------------------------------------------------------
void phRigidBodyShape::MakeRigidBody( d3Float mass )
{
__S_ASSERT( _rigidBody == NULL );
__S_ASSERT( _shape != NULL );
btVector3 inertia( 0.0f, 0.0f, 0.0f );
if( mass != 0.0 )
_shape->calculateLocalInertia( mass, inertia );
btRigidBody::btRigidBodyConstructionInfo rbInfo( mass, NULL, _shape, inertia );
_rigidBody = new btRigidBody( rbInfo );
}
/***********************************************************************/
/* phStaticPlane */
/***********************************************************************/
//----------------------------------------------------------------------
phStaticPlane::phStaticPlane( d3Object* owner ) :
_BaseClass( owner )
{
}
//----------------------------------------------------------------------
phStaticPlane::phStaticPlane( d3Object* owner, const d3Plane& plane ) :
_BaseClass( owner )
{
const d3Vector& normal = plane.Normal();
_shape = new btStaticPlaneShape(
btVector3( normal.x,normal.y,normal.z ),
btScalar( plane.GetD() )
);
MakeRigidBody( 0.0f );
}
//----------------------------------------------------------------------
void phStaticPlane::LoadFromXml( const Xml::BaseDomNode& element, LoadDataParams& loadParams ) throws_error
{
__S_ASSERT( _shape == NULL );
d3Float x = element.GetAttributeValue( _S("normal.x"), 0.0f );
d3Float y = element.GetAttributeValue( _S("normal.y"), 0.0f );
d3Float z = element.GetAttributeValue( _S("normal.z"), 0.0f );
d3Float c = element.GetAttributeValue( _S("const"), 0.0f );
_shape = new btStaticPlaneShape( btVector3( x,y,z ), btScalar( c ) );
MakeRigidBody( 0.0f );
}
/***********************************************************************/
/* phSphere */
/***********************************************************************/
//----------------------------------------------------------------------
phSphere::phSphere( d3Object* owner ):
_BaseClass( owner )
{
}
//----------------------------------------------------------------------
phSphere::phSphere( d3Object* owner, d3Float radius, d3Float mass ) :
_BaseClass( owner )
{
_shape = new btSphereShape( btScalar( radius ) );
MakeRigidBody( 0.0f );
}
//----------------------------------------------------------------------
void phSphere::LoadFromXml( const Xml::BaseDomNode& element, LoadDataParams& loadParams ) throws_error
{
__S_ASSERT( _shape == NULL );
d3Float mass = element.GetAttributeValue( _S("mass"), 0.0f );
d3Float r = element.GetAttributeValue( _S("radius"), 0.0f );
_shape = new btSphereShape( btScalar( r ) );
MakeRigidBody( mass );
}
}
#endif // ED3_ENGINE_USE_PHYSICS
| [
"sasha@Alexandru-Motriucs-MacBook-Pro.local"
] | sasha@Alexandru-Motriucs-MacBook-Pro.local |
55fd6e2a16de12c2852231edfda2a7a6062538ac | ff3571efe4612dfc69d84904eaac8f7291ae9995 | /3_Pointer&Memory/string_4.cpp | fd7235c85c921ee3faca31084dea1d5421d8249b | [] | no_license | bamin0422/Cpp_study | 0e9730c91f0389330b0f8c4e09f50f93292bc1eb | 70b1344b1c7434e57e80464b31850388fd64514f | refs/heads/master | 2021-01-26T05:43:23.813334 | 2020-05-16T11:13:33 | 2020-05-16T11:13:33 | 243,332,337 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 338 | cpp | #include <iostream>
using namespace std;
int main()
{
char s_str[30] = "", d_str[30] = "";
int i = 0;
cout << "주민등록번호 입력: ";
cin >> s_str;
for (i = 0; s_str[i] != '\0'; i++)
d_str[i] = s_str[i];
d_str[i] = s_str[i];
cout << s_str << endl;
cout << d_str << endl;
return 0;
} | [
"bamin0422@gmail.com"
] | bamin0422@gmail.com |
c409546b77b481ffb835da986593b54ac3517b8d | 0c868b796598a6fe9d9bc5ead91e331d33d1bc84 | /lib/mcts/include/PedestrianBelief.h | 050f8b58588fad31fc7371eb16680753befd54cb | [] | no_license | vislab-tecnico-lisboa/tracking_resource_allocation | 06fd2fc5367a511b2d81572d7524496a8d287705 | e204c76bb15c2c2c57b2e56b5652873301de224c | refs/heads/master | 2021-06-08T09:04:14.646201 | 2016-11-02T09:28:29 | 2016-11-02T09:28:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,754 | h | #pragma once
#include "ofxMSAmcts.h"
#include <opencv2/video/tracking.hpp>
#define kNumState 6
#define kNumObs 3
#define kNumActions 2
#define kTurnRangeMin -30
#define kTurnRangeMax 30
const double uniform_const=1.0;
const double scales_per_octave=8.0;
using namespace msa::mcts;
using namespace std;
namespace tracking {
class MyKalmanFilter : public cv::KalmanFilter
{
public:
MyKalmanFilter( const MyKalmanFilter& other )
{
statePre=other.statePre.clone(); //!< predicted state (x'(k)): x(k)=A*x(k-1)+B*u(k)
statePost=other.statePost.clone(); //!< corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
transitionMatrix=other.transitionMatrix.clone(); //!< state transition matrix (A)
measurementMatrix=other.measurementMatrix.clone(); //!< measurement matrix (H)
processNoiseCov=other.processNoiseCov.clone(); //!< process noise covariance matrix (Q)
measurementNoiseCov=other.measurementNoiseCov.clone();//!< measurement noise covariance matrix (R)
errorCovPre=other.errorCovPre.clone(); //!< priori error estimate covariance matrix (P'(k)): P'(k)=A*P(k-1)*At + Q)*/
gain=other.gain.clone(); //!< Kalman gain matrix (K(k)): K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
errorCovPost=other.errorCovPost.clone(); //!< posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)*H)*P'(k)
// do something with bar
}
MyKalmanFilter(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F):KalmanFilter(dynamParams, measureParams, controlParams, type)
{}
};
//--------------------------------------------------------------
//--------------------------------------------------------------
struct Action {
bool attend;
};
//--------------------------------------------------------------
//--------------------------------------------------------------
class Belief {
public:
unsigned int id;
float alpha_c;
float alpha_s;
//--------------------------------------------------------------
// MUST HAVE METHODS (INTERFACE)
Belief( const Belief& other) :
kalman_filter(other.kalman_filter),
mean(other.mean),
covariance(other.covariance),
id(other.id),
alpha_c(other.alpha_c),
alpha_s(other.alpha_s),
min_width(other.min_width),
min_height(other.min_height)
{}
Belief(const float & alpha_c_,
const float & alpha_s_,
const unsigned int & id_,
const cv::Mat & transition_matrix_,
const cv::Mat & measurement_matrix_,
const cv::Mat & processNoiseCov_,
const cv::Mat & state_,
const cv::Mat & cov_
) :
kalman_filter(kNumState,kNumObs,0),
alpha_c(alpha_c_),
alpha_s(alpha_s_),
id(id_)
{
// intialization of Kalman filter
kalman_filter.transitionMatrix = transition_matrix_;
kalman_filter.measurementMatrix=measurement_matrix_;
kalman_filter.processNoiseCov =processNoiseCov_;
kalman_filter.statePre=state_;
kalman_filter.statePost=state_;
kalman_filter.errorCovPre=cov_;
kalman_filter.errorCovPost=cov_;
mean=kalman_filter.statePre.rowRange(0,3);
covariance=kalman_filter.errorCovPost.rowRange(0,3).colRange(0,3);
//std::cout << "init:" << kalman_filter.measurementNoiseCov << std::endl;
}
~Belief()
{}
// whether or not this belief is terminal (reached end)
bool is_terminal() {
}
// agent id (zero-based) for agent who is about to make a decision
int agent_id() const {
return 0;
}
// apply action to state
void apply_action(const Action& action) {
//IT SHOULD FIRST OBSERVE AND THEN PREDICT (why?)
//std::cout << " id: "<< id << " action: "<< action.attend<< std::endl;
if(action.attend)
{
//std::cout << " scale before obs:"<< mean.at<float>(2) << std::endl;
//Observe
//std::cout << "before:" <<covariance<<std::endl;
get_measurement(mean.rowRange(0,3));
mean=kalman_filter.correct(mean.rowRange(0,3));
covariance = kalman_filter.errorCovPost.rowRange(0,3).colRange(0,3);
//std::cout << " scale after obs:"<< mean.at<float>(2) << std::endl;
//std::cout << "after:" <<covariance<<std::endl;
//std::cout << "measurementNoiseCov:" << kalman_filter.measurementNoiseCov<<std::endl;
}
// Predict
mean = kalman_filter.predict();
covariance = kalman_filter.errorCovPre.rowRange(0,3).colRange(0,3);
//std::cout << " scale predict:"<< mean.at<float>(2) << std::endl;
}
// return possible actions from this state
void get_actions(std::vector<Action>& actions) const {
actions.resize(kNumActions);
actions[0].attend=false;
actions[1].attend=true;
}
// get a random action, return false if no actions found
bool get_random_action(Action& action) const {
action.attend=rand()%2;
return true;
}
// evaluate this state and return a vector of rewards (for each agent)
/*const float evaluate() const {
// Negative entropy
float reward=100000.0-std::log(cv::determinant(covariance));
//std::cout << " reward:" << reward << std::endl;
return reward;
}*/
// evaluate this state and return a vector of rewards (for each agent)
const float entropy() const {
// entropy
float reward=std::log(cv::determinant(covariance));
//std::cout << " reward:" << reward << std::endl;
return reward;
}
//--------------------------------------------------------------
// IMPLEMENTATION SPECIFIC
MyKalmanFilter kalman_filter;
cv::Mat mean;
cv::Mat covariance;
float min_width=52, min_height=128;
void reset() {
}
void draw() {
}
// Observation model is dependent on the current state
cv::Mat get_measurement(const cv::Mat & state)
{
int n=8.0*log2(state.at<float>(2));
float q_scale =(pow(2,(float)(n+1)/scales_per_octave)-pow(2,(float)n/scales_per_octave));
float q_x=min_width*q_scale*0.5;
float q_y=min_height*q_scale*0.5;
cv::Mat cov=(cv::Mat_<float>(3, 3) << q_x*q_x*0.01, 0, 0, 0, q_y*q_y*0.01, 0, 0, 0, q_scale*q_scale*uniform_const);
kalman_filter.measurementNoiseCov=cov;
return state;
}
float compute_observation_region_area()
{
float scale=mean.at<float>(2);
float x_centroid_uncertainty=sqrt(covariance.at<float>(0,0));
float y_centroid_uncertainty=sqrt(covariance.at<float>(1,1));
float scale_uncertainty=sqrt(covariance.at<float>(2,2));
//std::cout << "scale_uncertainty: "<< scale_uncertainty <<" "<< x_centroid_uncertainty <<" "<<y_centroid_uncertainty << std::endl;
float total_scale=(scale+alpha_s*scale_uncertainty);
int n_rows=(total_scale * min_height) + alpha_c*x_centroid_uncertainty;
int n_cols=(total_scale * min_width) + alpha_c*y_centroid_uncertainty;
//std::cout << "scale:"<<scale<<" centroid_uncertainty:"<< centroid_uncertainty << " scale_uncertainty:"<< scale_uncertainty << " total scle:" <<total_scale<< std::endl;
float area=n_rows*n_cols;
//std::cout << "n_rows: "<< n_rows << " n_cols "<< n_cols << " area:" << area<< std::endl;
//std::cout << kalman_filter.errorCovPre.at<float>(2,2) << std::endl;
return area;
// Region size constraint: if total area > max allowed - > terminal belief
}
};
}
| [
"ruihortafigueiredo@gmail.com"
] | ruihortafigueiredo@gmail.com |
dab604c67dfb55c2e0197dba998a22ba14f7a4c1 | 427f48b76d1b312cff7af2d9b535ea333e8d154e | /cpp/container_span_first.cpp | b9b13d4a4bac0f0da0758a25894ba57f48df0068 | [
"MIT"
] | permissive | rpuntaie/c-examples | 8925146dd1a59edb137c6240363e2794eccce004 | 385b3c792e5b39f81a187870100ed6401520a404 | refs/heads/main | 2023-05-31T15:29:38.919736 | 2021-06-28T16:53:07 | 2021-06-28T16:53:07 | 381,098,552 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 950 | cpp | /*
g++ --std=c++20 -pthread -o ../_build/cpp/container_span_first.exe ./cpp/container_span_first.cpp && (cd ../_build/cpp/;./container_span_first.exe)
https://en.cppreference.com/w/cpp/container/span/first
*/
#include <iostream>
#include <span>
#include <string_view>
void print(std::string_view const title,
/* std::ranges::forward_range */ auto const& container) {
std::cout << title << "[" << std::size(container) << "]{ ";
for (auto const& elem : container)
std::cout << elem << ", ";
std::cout << "};\n";
}
void run_game(std::span<const int> span)
{
print("span: ", span);
std::span<const int, 5> span_first = span.first<5>();
print("span.first<5>(): ", span_first);
std::span<const int, std::dynamic_extent> span_first_dynamic = span.first(4);
print("span.first(4): ", span_first_dynamic);
}
int main()
{
int a[8]{ 1, 2, 3, 4, 5, 6, 7, 8, };
print("int a", a);
run_game(a);
}
| [
"roland.puntaier@gmail.com"
] | roland.puntaier@gmail.com |
e8689f1ecc79872856d855022214be3c8d9831e4 | 844969bd953d7300f02172c867725e27b518c08e | /SDK/OOSLetter_ExclusionEntitlement_Campaign026_functions.cpp | bd522d5fad7af0fdc92ad04a9e3806146104ed42 | [] | no_license | zanzo420/SoT-Python-Offset-Finder | 70037c37991a2df53fa671e3c8ce12c45fbf75a5 | d881877da08b5c5beaaca140f0ab768223b75d4d | refs/heads/main | 2023-07-18T17:25:01.596284 | 2021-09-09T12:31:51 | 2021-09-09T12:31:51 | 380,604,174 | 0 | 0 | null | 2021-06-26T22:07:04 | 2021-06-26T22:07:03 | null | UTF-8 | C++ | false | false | 602 | cpp | // Name: SoT, Version: 2.2.1.1
#include "../pch.h"
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------
void UOOSLetter_ExclusionEntitlement_Campaign026_C::AfterRead()
{
UEntitlementDesc::AfterRead();
}
void UOOSLetter_ExclusionEntitlement_Campaign026_C::BeforeDelete()
{
UEntitlementDesc::BeforeDelete();
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"51171051+DougTheDruid@users.noreply.github.com"
] | 51171051+DougTheDruid@users.noreply.github.com |
e8e00543f16896c4c8a73e402197d3a89245fd01 | c3ffda360b1c77218ee4b09ef941ef2e58a82ec3 | /Playground/OldStuff/facebookcpp/Sources/FacebookCpp/src/Method/GetUsersInfo.cpp | 37362e019090d182eaf553e0b827534e46c24b63 | [] | no_license | StackedCrooked/stacked-crooked | 187ab1f9465223949732336444aa104277223072 | 08cd3e7ea1d7d326792c536f0346f220c347f5e4 | refs/heads/master | 2023-08-15T15:37:43.635922 | 2023-07-19T22:47:46 | 2023-07-19T22:47:46 | 32,498,571 | 5 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 18,716 | cpp | #include "FacebookCpp/Method/GetUsersInfo.h"
#include "Poco/SAX/InputSource.h"
#include "Poco/SAX/SAXParser.h"
#include "Poco/String.h"
#include <iostream>
using namespace FacebookCpp;
using namespace Poco;
using namespace XML;
using namespace std;
std::map<std::string, GetUsersInfo::FbStruct> GetUsersInfo::sMapping_ElementName_FbStruct;
GetUsersInfo::GetUsersInfo
(
const Session & inSession,
const vector<string> & inUids,
const AbstractDelegate<ResponseType> & inSuccessCallback,
const AbstractDelegate<ErrorResponse> & inErrorCallback
):
FacebookSessionMethod(inSession, "Users.getInfo", inErrorCallback),
mUids(inUids),
mCurrentStruct(eNone),
mSuccessCallback(inSuccessCallback)
{
mParams["uids"] = toCSV(inUids);
mParams["fields"] += "about_me";
mParams["fields"] += ",activities";
mParams["fields"] += ",affiliations";
mParams["fields"] += ",birthday";
mParams["fields"] += ",books";
mParams["fields"] += ",current_location";
mParams["fields"] += ",education_history";
mParams["fields"] += ",first_name";
mParams["fields"] += ",has_added_app";
mParams["fields"] += ",hometown_location";
mParams["fields"] += ",hs_info";
mParams["fields"] += ",interests";
mParams["fields"] += ",is_app_user";
mParams["fields"] += ",last_name";
mParams["fields"] += ",meeting_for";
mParams["fields"] += ",meeting_sex";
mParams["fields"] += ",movies";
mParams["fields"] += ",music";
mParams["fields"] += ",name";
mParams["fields"] += ",notes_count";
mParams["fields"] += ",pic";
mParams["fields"] += ",pic_big";
mParams["fields"] += ",pic_small";
mParams["fields"] += ",pic_square";
mParams["fields"] += ",political";
mParams["fields"] += ",profile_update_time";
mParams["fields"] += ",quotes";
mParams["fields"] += ",relationship_status";
mParams["fields"] += ",religion";
mParams["fields"] += ",sex";
mParams["fields"] += ",significant_other_id";
mParams["fields"] += ",status";
mParams["fields"] += ",timezone";
mParams["fields"] += ",tv";
mParams["fields"] += ",uid";
mParams["fields"] += ",wall_count";
mParams["fields"] += ",work_history";
}
void GetUsersInfo::setDocumentLocator(const Locator* loc)
{
}
void GetUsersInfo::startDocument()
{
}
void GetUsersInfo::endDocument()
{
}
void GetUsersInfo::startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attrList)
{
if(sMapping_ElementName_FbStruct.empty())
{
sMapping_ElementName_FbStruct["affiliations"] = eAffiliationList;
sMapping_ElementName_FbStruct["current_location"] = eCurrentLocation;
sMapping_ElementName_FbStruct["education_history"] = eEducationHistory;
sMapping_ElementName_FbStruct["hometown_location"] = eHomeTownLocation;
sMapping_ElementName_FbStruct["hs_info"] = eHighschoolInfo;
sMapping_ElementName_FbStruct["meeting_for"] = eMeetingFor;
sMapping_ElementName_FbStruct["meeting_sex"] = eMeetingSex;
sMapping_ElementName_FbStruct["status"] = eStatus;
sMapping_ElementName_FbStruct["work_history"] = eWorkHistory;
}
if(mCurrentStruct == eNone)
{
if(sMapping_ElementName_FbStruct.find(localName) != sMapping_ElementName_FbStruct.end())
{
mCurrentStruct = sMapping_ElementName_FbStruct[localName];
}
}
else
{
switch(mCurrentStruct)
{
case eAffiliationList:
{
// <affiliations list="true">
// <affiliation>
// <nid>50453093</nid>
// <name>Facebook Developers</name>
// <type>work</type>
// <status/>
// <year/>
// </affiliation>
// </affiliations>
if(localName == "affiliation")
{
mCurrentStruct = eAffiliationList_Affiliation;
}
else
{
mCurrentStruct = eNone;
}
break;
}
case eEducationHistory:
{
// <education_history list="true">
// <education_info>
// <name>Harvard</name>
// <year>2003</year>
// <concentrations list="true">
// <concentration>Applied Mathematics</concentration>
// <concentration>Computer Science</concentration>
// </concentrations>
// <degree>MS</degree>
// </education_info>
// </education_history>
if(localName == "education_info")
{
mCurrentStruct = eEducationHistory_EducationInfo;
}
else
{
mCurrentStruct = eNone;
}
break;
}
case eEducationHistory_EducationInfo:
{
if(localName == "concentrations")
{
mCurrentStruct = eEducationHistory_EducationInfo_Concentrations;
}
else
{
mCurrentStruct = eEducationHistory;
}
break;
}
case eWorkHistory:
{
// <work_history list="true">
// <work_info>
// <location>
// <city>Palo Alto</city>
// <state>CA</state>
// <country>United States</country>
// </location>
// <company_name>Facebook</company_name>
// <position>Software Engineer</position>
// <description>Tech Lead, Facebook Platform</description>
// <start_date>2006-01</start_date>
// <end_date/>
// </work_info>
// </work_history>
if(localName == "work_info")
{
mCurrentStruct = eWorkHistory_WorkInfo;
}
else
{
mCurrentStruct = eNone;
}
break;
}
case eWorkHistory_WorkInfo:
{
if(localName == "location")
{
mCurrentStruct = eWorkHistory_WorkInfo_Location;
}
else
{
mCurrentStruct = eWorkHistory;
}
break;
}
default:
{
mCurrentStruct = eNone;
break;
}
};
}
mLocalName = localName;
}
void GetUsersInfo::endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname)
{
switch(mCurrentStruct)
{
case eNone:
{
if(localName == "user")
{
mUserInfoList.push_back(mUserInfo);
mUserInfo = UserInfo();
}
else if(localName == "about_me")
{
mUserInfo.setAboutMe(mCurrentString);
}
else if(localName == "activities")
{
mUserInfo.setActivities(mCurrentString);
}
else if(localName == "birthday")
{
mUserInfo.setBirthday(mCurrentString);
}
else if(localName == "books")
{
mUserInfo.setBooks(mCurrentString);
}
else if(localName == "first_name")
{
mUserInfo.setFirstName(mCurrentString);
}
else if(localName == "has_added_app")
{
mUserInfo.setHasAddedApp(trim(mCurrentString) == "1");
}
else if(localName == "interests")
{
mUserInfo.setInterests(mCurrentString);
}
else if(localName == "is_app_user")
{
mUserInfo.setIsAppUser(trim(mCurrentString) == "1");
}
else if(localName == "last_name")
{
mUserInfo.setLastName(mCurrentString);
}
else if(localName == "movies")
{
mUserInfo.setMovies(mCurrentString);
}
else if(localName == "music")
{
mUserInfo.setMusic(mCurrentString);
}
else if(localName == "name")
{
mUserInfo.setName(mCurrentString);
}
else if(localName == "notes_count")
{
string notesCountString = trim(mCurrentString);
istringstream ss(notesCountString);
int notesCount;
ss >> notesCount;
mUserInfo.setNotesCount(notesCount);
}
else if(localName == "pic")
{
mUserInfo.setPicUrl(mCurrentString);
}
else if(localName == "pic_big")
{
mUserInfo.setPicBigUrl(mCurrentString);
}
else if(localName == "pic_small")
{
mUserInfo.setPicSmallUrl(mCurrentString);
}
else if(localName == "pic_square")
{
mUserInfo.setPicSquareUrl(mCurrentString);
}
else if(localName == "political")
{
mUserInfo.setPolitical(mCurrentString);
}
else if(localName == "profile_update_time")
{
mUserInfo.setProfileUpdateTime(mCurrentString);
}
else if(localName == "quotes")
{
mUserInfo.setQuotes(mCurrentString);
}
else if(localName == "relationship_status")
{
mUserInfo.setRelationshipStatus(mCurrentString);
}
else if(localName == "religion")
{
mUserInfo.setReligion(mCurrentString);
}
else if(localName == "sex")
{
mUserInfo.setSex(mCurrentString);
}
else if(localName == "significant_other_id")
{
mUserInfo.setSignificantOtherId(mCurrentString);
}
else if(localName == "timezone")
{
string timeZoneString = trim(mCurrentString);
istringstream ss(timeZoneString);
int timeZone;
ss >> timeZone;
mUserInfo.setTimeZone(timeZone);
}
else if(localName == "tv")
{
mUserInfo.setTv(mCurrentString);
}
else if(localName == "uid")
{
mUserInfo.setUid(mCurrentString);
}
else if(localName == "wall_count")
{
string wallCountString = trim(mCurrentString);
istringstream ss(wallCountString);
int wallCount;
ss >> wallCount;
mUserInfo.setWallCount(wallCount);
}
break;
}
case eAffiliationList:
{
mUserInfo.setAffiliations(mAffiliations);
mCurrentStruct = eNone;
break;
}
case eAffiliationList_Affiliation:
{
mAffiliations.push_back(mAffiliation);
mAffiliation = UserInfo::Affiliation();
mCurrentStruct = eAffiliationList;
break;
}
case eHomeTownLocation:
{
mUserInfo.setHomeTownLocation(mHomeTownLocation);
mHomeTownLocation = UserInfo::HomeTownLocation();
mCurrentStruct = eNone;
break;
}
case eCurrentLocation:
{
mUserInfo.setCurrentLocation(mCurrentLocation);
mCurrentLocation = UserInfo::Location();
mCurrentStruct = eNone;
break;
}
case eEducationHistory:
{
mUserInfo.setEducationInfoList(mEducationHistory);
mEducationHistory.clear();
mCurrentStruct = eNone;
break;
}
case eEducationHistory_EducationInfo:
{
mEducationHistory.push_back(mEducationInfo);
mEducationInfo = UserInfo::EducationInfo();
mCurrentStruct = eEducationHistory;
break;
}
case eEducationHistory_EducationInfo_Concentrations:
{
mEducationInfo.Concentrations = mEducationConcentrations;
mEducationConcentrations.clear();
mCurrentStruct = eEducationHistory_EducationInfo;
break;
}
case eHighschoolInfo:
{
mUserInfo.setHighSchoolInfo(mHighschoolInfo);
mHighschoolInfo = UserInfo::HighschoolInfo();
mCurrentStruct = eNone;
break;
}
case eStatus:
{
mUserInfo.setStatus(mStatus);
mStatus = UserInfo::Status();
mCurrentStruct = eNone;
break;
}
case eWorkHistory:
{
mUserInfo.setWorkInfoList(mWorkHistory);
mWorkHistory.clear();
mCurrentStruct = eNone;
break;
}
case eWorkHistory_WorkInfo:
{
mWorkHistory.push_back(mWorkInfo);
mWorkInfo = UserInfo::WorkInfo();
mCurrentStruct = eWorkHistory;
break;
}
case eWorkHistory_WorkInfo_Location:
{
mWorkInfo.Location = mWorkInfoLocation;
mWorkInfoLocation = UserInfo::Location();
mCurrentStruct = eWorkHistory_WorkInfo;
break;
}
}
mCurrentString = "";
}
void GetUsersInfo::characters(const XMLChar ch[], int start, int length)
{
string content(ch + start, length);
switch(mCurrentStruct)
{
case eNone:
{
mCurrentString += content;
break;
}
case eAffiliationList:
{
// <affiliations list="true">
// <affiliation>
// <nid>50453093</nid>
// <name>Facebook Developers</name>
// <type>work</type>
// <status/>
// <year/>
// </affiliation>
// </affiliations>
// do nothing...
break;
}
case eAffiliationList_Affiliation:
{
// <affiliation>
// <nid>50453093</nid>
// <name>Facebook Developers</name>
// <type>work</type>
// <status/>
// <year/>
// </affiliation>
if(mLocalName == "nid")
{
mAffiliation.Nid += content;
}
else if(mLocalName == "name")
{
mAffiliation.Name += content;
}
else if(mLocalName == "type")
{
mAffiliation.Type += content;
}
else if(mLocalName == "status")
{
mAffiliation.Status += content;
}
else if(mLocalName == "year")
{
mAffiliation.Year = content;
}
break;
}
case eHomeTownLocation:
{
// <hometown_location>
// <city>York</city>
// <state>PA</state>
// <country>United States</country>
// <zip>0</zip>
// </hometown_location>
if(mLocalName == "city")
{
mHomeTownLocation.City += content;
}
else if(mLocalName == "state")
{
mHomeTownLocation.State += content;
}
else if(mLocalName == "country")
{
mHomeTownLocation.Country += content;
}
else if(mLocalName == "zip")
{
mHomeTownLocation.Zip += content;
}
break;
}
case eCurrentLocation:
{
// <current_location>
// <city>Palo Alto</city>
// <state>CA</state>
// <country>United States</country>
// <zip>94303</zip>
// </current_location>
if(mLocalName == "city")
{
mCurrentLocation.City += content;
}
else if(mLocalName == "state")
{
mCurrentLocation.State += content;
}
else if(mLocalName == "country")
{
mCurrentLocation.Country += content;
}
else if(mLocalName == "zip")
{
mCurrentLocation.Zip += content;
}
break;
}
case eEducationHistory:
{
// <education_history list="true">
// <education_info>
// <name>Harvard</name>
// <year>2003</year>
// <concentrations list="true">
// <concentration>Applied Mathematics</concentration>
// <concentration>Computer Science</concentration>
// </concentrations>
// <degree>MS</degree>
// </education_info>
// </education_history>
// no useful information...
break;
}
case eEducationHistory_EducationInfo:
{
// <education_info>
// <name>Harvard</name>
// <year>2003</year>
// <concentrations list="true">
// <concentration>Applied Mathematics</concentration>
// <concentration>Computer Science</concentration>
// </concentrations>
// <degree>MS</degree>
// </education_info>
if(mLocalName == "name")
{
mEducationInfo.School += content;
}
else if(mLocalName == "year")
{
mEducationInfo.Year += content;
}
else if(mLocalName == "degree")
{
mEducationInfo.Degree += content;
}
break;
}
case eEducationHistory_EducationInfo_Concentrations:
{
// <concentrations list="true">
// <concentration>Applied Mathematics</concentration>
// <concentration>Computer Science</concentration>
// </concentrations>
if(mLocalName == "concentration")
{
mEducationConcentration += content;
}
break;
}
case eHighschoolInfo:
{
// <hs_info>
// <hs1_name>Central York High School</hs1_name>
// <hs2_name/>
// <grad_year>1999</grad_year>
// <hs1_id>21846</hs1_id>
// <hs2_id>0</hs2_id>
// </hs_info>
if(mLocalName == "hs1_name")
{
mHighschoolInfo.HsName += content;
}
else if(mLocalName == "hs2_name")
{
mHighschoolInfo.Hs2Name += content;
}
else if(mLocalName == "grad_year")
{
mHighschoolInfo.GradYear += content;
}
else if(mLocalName == "hs1_id")
{
mHighschoolInfo.Hs1Id += content;
}
else if(mLocalName == "hs2_id")
{
mHighschoolInfo.Hs2Id += content;
}
break;
}
case eStatus:
{
// <status>
// <message/>
// <time>0</time>
// </status>
if(mLocalName == "message")
{
mStatus.Message += content;
}
else if(mLocalName == "time")
{
mStatus.Time += content;
}
break;
}
case eWorkHistory:
{
// <work_history list="true">
// <work_info>
// <location>
// <city>Palo Alto</city>
// <state>CA</state>
// <country>United States</country>
// </location>
// <company_name>Facebook</company_name>
// <position>Software Engineer</position>
// <description>Tech Lead, Facebook Platform</description>
// <start_date>2006-01</start_date>
// <end_date/>
// </work_info>
// </work_history>
// no interesting information...
break;
}
case eWorkHistory_WorkInfo:
{
// <work_info>
// <location>
// <city>Palo Alto</city>
// <state>CA</state>
// <country>United States</country>
// </location>
// <company_name>Facebook</company_name>
// <position>Software Engineer</position>
// <description>Tech Lead, Facebook Platform</description>
// <start_date>2006-01</start_date>
// <end_date/>
// </work_info>
if(mLocalName == "company_name")
{
mWorkInfo.CompanyName += content;
}
else if(mLocalName == "position")
{
mWorkInfo.Position += content;
}
else if(mLocalName == "description")
{
mWorkInfo.Description += content;
}
else if(mLocalName == "start_date")
{
mWorkInfo.StartDate += content;
}
else if(mLocalName == "end_date")
{
mWorkInfo.EndDate += content;
}
break;
}
case eWorkHistory_WorkInfo_Location:
{
// <location>
// <city>Palo Alto</city>
// <state>CA</state>
// <country>United States</country>
// </location>
if(mLocalName == "city")
{
mWorkInfoLocation.City += content;
}
else if(mLocalName == "state")
{
mWorkInfoLocation.State += content;
}
else if(mLocalName == "country")
{
mWorkInfoLocation.City += content;
}
break;
}
}
}
void GetUsersInfo::ignorableWhitespace(const XMLChar ch[], int start, int length)
{
}
void GetUsersInfo::processingInstruction(const XMLString& target, const XMLString& data)
{
}
void GetUsersInfo::startPrefixMapping(const XMLString& prefix, const XMLString& uri)
{
}
void GetUsersInfo::endPrefixMapping(const XMLString& prefix)
{
}
void GetUsersInfo::skippedEntity(const XMLString& name)
{
}
void GetUsersInfo::handleResponse(istream & inputstream) const
{
SAXParser parser;
parser.setFeature(XMLReader::FEATURE_NAMESPACES, true);
parser.setFeature(XMLReader::FEATURE_NAMESPACE_PREFIXES, true);
parser.setContentHandler(const_cast<GetUsersInfo*>(this));
try
{
SharedPtr<InputSource> inputSource(new InputSource(inputstream));
parser.parse(inputSource);
mSuccessCallback.call(mUserInfoList);
}
catch (Exception& e)
{
cerr << e.displayText() << endl;
mErrorCallback.call(ErrorResponse(0,e.message(), KeyValue()));
}
}
| [
"StackedCrooked@users.noreply.github.com"
] | StackedCrooked@users.noreply.github.com |
848e4e191524f15c247afc453a6a2f1d0b56d82a | 1f30943b7847a136826f6bcad7ad45a081aa5f89 | /geometry/render/gl_renderer/test/shader_program_test.cc | b3b1b2aad374f6678d028ef90dda6fcd2d54d623 | [
"BSD-3-Clause"
] | permissive | ashishraste/drake | a368390bfe9bb92908185eb3883b333af0f09731 | da9e9f2e868c0ea42b9059c94c60e212b8c23f43 | refs/heads/master | 2022-11-16T05:43:13.114253 | 2020-07-05T00:05:11 | 2020-07-05T00:05:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,282 | cc | #include "drake/geometry/render/gl_renderer/shader_program.h"
#include <fstream>
#include <memory>
#include <string>
#include <gtest/gtest.h>
#include "drake/common/temp_directory.h"
#include "drake/common/test_utilities/expect_throws_message.h"
#include "drake/geometry/render/gl_renderer/opengl_context.h"
namespace drake {
namespace geometry {
namespace render {
namespace internal {
namespace {
constexpr char kVertexSource[] = R"_(
#version 330
void main() {
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
}
)_";
constexpr char kFragmentSource[] = R"_(
#version 330
uniform float test_uniform;
void main() {
gl_FragColor = vec4(0.18, 0.54, 0.34, test_uniform);
}
)_";
} // namespace
using std::string;
// Test class is *not* in the anonymous namespace so it can exploit the
// declared friend status in ShaderProgram.
class ShaderProgramTest : public ::testing::Test {
protected:
void SetUp() override {
// ShaderProgram requires an active OpenGL context to perform.
opengl_context_ = std::make_shared<OpenGlContext>();
}
// Reports the program id of the given program.
static GLuint program_id(const ShaderProgram& program) {
return program.program_id_;
}
private:
std::shared_ptr<OpenGlContext> opengl_context_;
};
// Test the shader program loading. This tests both sources stored in strings as
// well as reading from disk. We've created an immensely simple shader and just
// want to make sure it loads/compiles without difficulty.
TEST_F(ShaderProgramTest, LoadShaders) {
{
// Case: Load from in-memory vertex and fragment shaders.
ShaderProgram program;
EXPECT_EQ(program_id(program), 0);
EXPECT_NO_THROW(
program.LoadFromSources(kVertexSource, kFragmentSource));
EXPECT_NE(program_id(program), 0);
}
{
// Case: Load the same shaders from disk.
auto write_shader = [](const string& file_name, const char* shader) {
std::ofstream file(file_name);
if (!file) throw std::logic_error("Can't write file");
file << shader;
};
const string temp_dir = temp_directory();
const string vertex_shader(temp_dir + "/vertex.glsl");
const string fragment_shader(temp_dir + "/fragment.glsl");
write_shader(vertex_shader, kVertexSource);
write_shader(fragment_shader, kFragmentSource);
ShaderProgram program;
EXPECT_NO_THROW(program.LoadFromFiles(vertex_shader, fragment_shader));
EXPECT_NE(program_id(program), 0);
}
}
// Confirms the error conditions for loading vertex and fragment shaders. These
// exercise ShaderProgram::LoadFromSources, relying on the fact that
// ShaderProgram::LoadFromFiles ultimately exercises those.
TEST_F(ShaderProgramTest, LoadShadersError) {
// We'll create a "bad" shader by simply passing garbage. We're ignoring the
// details of the compilation error reported by the OpenGL driver. The
// error regular expression uses "[^]+" instead of ".+" because the error
// may include line breaks and ".+" does *not* include line breaks.
ShaderProgram program;
{
// Case: Bad vertex shader.
DRAKE_EXPECT_THROWS_MESSAGE(
program.LoadFromSources("This is garbage", kFragmentSource),
std::runtime_error,
"Error compiling vertex shader[^]+");
}
{
// Case: Bad fragment shader.
DRAKE_EXPECT_THROWS_MESSAGE(
program.LoadFromSources(kVertexSource, "This is garbage"),
std::runtime_error,
"Error compiling fragment shader[^]+");
}
{
// Case: Both shaders are bad. This stops at reporting the vertex error.
DRAKE_EXPECT_THROWS_MESSAGE(
program.LoadFromSources("This is garbage", "also garbage"),
std::runtime_error,
"Error compiling vertex shader[^]+");
}
{
// Case: linker error. To trigger the linker error, we omit the main
// function from the fragment shader as documented here:
// https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glLinkProgram.xhtml
DRAKE_EXPECT_THROWS_MESSAGE(
program.LoadFromSources(kVertexSource, R"_(
#version 100
void foo() {
gl_FragColor = vec4(0.1, 0.2, 0.3, 1.0);
})_"),
std::runtime_error, "Error linking shaders[^]+");
}
{
// Case: file referenced is not available.
DRAKE_EXPECT_THROWS_MESSAGE(
program.LoadFromFiles("invalid.vert", "invalid.frag"),
std::runtime_error, "Error opening shader file: .+");
}
}
TEST_F(ShaderProgramTest, UniformAccess) {
ShaderProgram program;
program.LoadFromSources(kVertexSource, kFragmentSource);
EXPECT_NO_THROW(program.GetUniformLocation("test_uniform"));
DRAKE_EXPECT_THROWS_MESSAGE(program.GetUniformLocation("invalid"),
std::runtime_error,
"Cannot get shader uniform invalid");
EXPECT_NO_THROW(program.SetUniformValue("test_uniform", 1.5f));
DRAKE_EXPECT_THROWS_MESSAGE(program.SetUniformValue("invalid", 1.75f),
std::runtime_error,
"Cannot get shader uniform invalid");
}
TEST_F(ShaderProgramTest, Binding) {
ShaderProgram program1;
program1.LoadFromSources(kVertexSource, kFragmentSource);
ShaderProgram program2;
program2.LoadFromSources(kVertexSource, kFragmentSource);
// Report the id of the currently bound program.
auto current_program = []() {
GLint curr_program;
glGetIntegerv(GL_CURRENT_PROGRAM, &curr_program);
return static_cast<GLuint>(curr_program);
};
// We start with nothing bound; creating a program isn't the same as binding
// it.
ASSERT_EQ(current_program(), 0);
// Bind one of the programs.
ASSERT_NO_THROW(program1.Use());
ASSERT_EQ(current_program(), program_id(program1));
// Binding another causes the current program to switch.
ASSERT_NO_THROW(program2.Use());
ASSERT_EQ(current_program(), program_id(program2));
// Attempting to unbind with the wrong program has no effect.
ASSERT_NO_THROW(program1.Unuse());
ASSERT_EQ(current_program(), program_id(program2));
// Unbinding the current program clears it.
ASSERT_NO_THROW(program2.Unuse());
ASSERT_EQ(current_program(), 0);
}
} // namespace internal
} // namespace render
} // namespace geometry
} // namespace drake
| [
"noreply@github.com"
] | noreply@github.com |
1624ec2e6c2c13b25ab99a5b70eb4d73d7f05aa9 | f76c467deed8763ca47ff37fa25be249bd53ded3 | /PAT/Basic/PAT1023.cpp | 5341e1dcff5505b8c62b65b04fd1bc7ca2576f7e | [] | no_license | FiveLemon/Code | 3e0aa9944d81dec5951b6166e9e62122815e8994 | 27b1ca436cbd230a5a15c80cabd3451dd69f6c37 | refs/heads/master | 2021-10-09T01:41:37.304186 | 2018-12-20T03:15:23 | 2018-12-20T03:15:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 991 | cpp | #include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<sstream>
using namespace std;
template<class out, class in>
out ConvertDataType(const in& a);
int main()
{
vector<int> data;
int number;
int counter = 10;
vector<int>::iterator start;
string figure;
while(counter--)
{
cin>>number;
data.push_back(number);
}
for(start = data.begin(); start != data.end(); start++)
{
if (0 != *start && start - data.begin() != 0)
{
figure = ConvertDataType<string>(start - data.begin());
(*start)--;
break;
}
}
for(start = data.begin(); start != data.end(); start++)
{
figure.insert(figure.end(), *start, ConvertDataType<char>(start - data.begin()));
}
cout<<figure<<endl;
return 0;
}
template<class out, class in>
out ConvertDataType(const in& a)
{
std::stringstream temp;
temp<<a;
out b;
temp>>b;
return b;
} | [
"qinchuanqing918@163.com"
] | qinchuanqing918@163.com |
2afd734dd491d04ddb81220b54dd113f28f815d6 | 3b084e3dd39850597bdc22ca8accb4c84706b643 | /thisjuly2.cpp | 3092d13efed92c18836cb2537e56923cffe92871 | [] | no_license | prasadgujar/Programming | bc429430056db6b5d1bea23df4a66af800861e0e | 3622ba240f3727c27ce26e70bfeafffb1553f6b7 | refs/heads/master | 2021-01-25T16:59:54.056472 | 2018-01-14T12:37:17 | 2018-01-14T12:37:17 | 102,753,402 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,723 | cpp | #include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define vpii vector<pii>
#define fi first
#define se second
#define FOR(i,n) for(int (i)=0;(i)<(n);++(i))
#define FORI(i,n) for(int (i)=1;(i)<=(n);++(i))
#define IN(x,y) ((y).find(x)!=(y).end())
#define ALL(t) t.begin(),t.end()
#define TLIMIT 1000000
#define MAXLIMIT 100006
typedef unsigned long long ull;
typedef long double ldb;
typedef long long ll;
typedef long long int lli;
typedef stringstream SS;
typedef vector<string> VS;
typedef vector<ll> VI;
typedef vector<char> VC;
typedef map<string, string> MSS;
typedef map <ll,string> MIS;
typedef map <char,ll> MCI;
typedef map <string,ll> MSI;
typedef map <ll,ll> MII;
long long int t;
char s[MAXLIMIT];
char compare;
void work()
{
std::cin>>s;
char s1[MAXLIMIT]="";
long long int i , j;
for(i = 0, j = 0; s[i]!='\0';i++)
{
if(s[i]!='=')
{
s1[j]=s[i];
j++;
}
}
lli result=0, cn=0,length;
length = j;
if (length!=0)
{
i = 0;
while(i<j)
{
compare = s1[i];
i++;
cn = 1;
while(i<length&&s1[i]==compare)
{
cn++;
i++;
}
result = max(result,cn);
}
}
std::cout<<result+1<<'\n';
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int t;
std::cin>>t;
assert(1 <= t && t <= TLIMIT);
while(t--)
{
work();
}
return 0;
}
| [
"prasadgujar16@gmail.com"
] | prasadgujar16@gmail.com |
84d7e9aa65f175d41800d6c73a5f06d9d1068812 | f9875c7e397ef3fb9bedd0bc4d482da6f6612f0f | /script/PixImgDisp.cpp | 568d172c1d889393925dd7ffeeb50f1856d595e4 | [] | no_license | a8039974/XrayCT | 57e0816f993a65e75168c800d07187266ad4b275 | ad6e05ad2d724eaf74f5df261fa073ace6f438da | refs/heads/master | 2021-09-14T12:10:13.964163 | 2018-05-13T14:43:18 | 2018-05-13T14:43:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,000 | cpp | // Display and save pixel reconstruction results from data files
#include "CmdTools.hpp"
#include "T2D.hpp"
#include <tclap/CmdLine.h>
int main(int argc, char **argv) {
TCLAP::CmdLine cmd("Interpolate and display a region of a pixel image on screen.");
TCLAP::UnlabeledValueArg<string> inpath_fnameArg("inpath_fname","Input data directory name",true,"","string", cmd);
TCLAP::UnlabeledValueArg<string> im_fnameArg("im_fname","Phantom image name",false,"","string", cmd);
//TCLAP::SwitchArg imageSwitch("", "image", "Input coefficient is an image file. [false]", cmd, false);
TCLAP::ValueArg<int> rowArg("", "row", "Row dimension . [256]", true, 256, "int", cmd);
TCLAP::ValueArg<int> colArg("", "col", "Column dimension . [256]", true, 256, "int", cmd);
TCLAP::ValueArg<string> xr_fnameArg("", "xr","Input coefficient file name",false,"xr.dat","string", cmd);
TCLAP::ValueArg<int> dimArg("", "dim", "Resolution of the larger side of interpolation region . [0]", false, 0, "int", cmd);
TCLAP::SwitchArg oserrSwitch("", "oserr", "Introduce a offset error in the resampling to prevent perfect fitting. [false]", cmd, false);
// TCLAP::ValueArg<int> dimrArg("", "dimr", "Row resolution of interpolation region . [0]", false, 0, "int", cmd);
// TCLAP::ValueArg<int> dimcArg("", "dimc", "Column resolution of interpolation region . [0]", false, 0, "int", cmd);
//TCLAP::SwitchArg gradSwitch("", "grad", "Gradient of image. [false]", cmd, false);
TCLAP::ValueArg<double> wlowArg("", "wlow", "[-255]", false, -255, "double", cmd);
TCLAP::ValueArg<double> whighArg("", "whigh", "[255]", false, 255, "double", cmd);
//TCLAP::ValueArg<size_t> gpuidArg("g", "gpuid", "ID of gpu device to use. [0]", false, 0, "size_t", cmd);
TCLAP::SwitchArg verboseSwitch("v", "verbose", "Print informations and display image. [quite]", cmd, false);
cmd.parse(argc, argv);
string inpath_fname = inpath_fnameArg.getValue();
string im_fname = im_fnameArg.getValue();
string xr_fname = xr_fnameArg.getValue();
int dim = dimArg.getValue();
bool oserr = oserrSwitch.getValue();
// int dimr = dimrArg.getValue();
// int dimc = dimcArg.getValue();
int drow = rowArg.getValue();
int dcol = colArg.getValue();
int nrow, ncol; // the dimension to be resampled
char buffer[256];
//bool grad = gradSwitch.getValue();
double wlow = wlowArg.getValue();
double whigh = whighArg.getValue();
bool verbose = verboseSwitch.getValue();
// Load coefficients
ArrayXd Xr = CmdTools::loadarray(inpath_fname+"/"+xr_fname, drow*dcol);
if (wlow > Xr.minCoeff())
Xr = (Xr<wlow).select(0, Xr);
if (whigh < Xr.maxCoeff())
Xr = (Xr>whigh).select(whigh, Xr);
ImageXXd imr = Map<ImageXXd>(Xr.data(), drow, dcol);
if (im_fname != "") {
ImageXXd im = CmdTools::imread(im_fname);
imr = Tools::resampling_piximg(Xr.data(), drow, dcol, im.rows(), im.cols(), oserr);
// double pixSize = fmax(dcol *1./ im.cols(), drow *1./ im.rows());
// imr = Tools::resampling_piximg(Xr.data(), drow, dcol, 1., im.rows(), im.cols(), pixSize);
double recuqi = Tools::UQI(imr, im);
double recmse = (imr-im).matrix().squaredNorm() / im.size();
double recsnr = Tools::SNR(imr, im);
double reccorr = Tools::Corr(imr, im);
double recsi = Tools::StreakIndex(imr, im);
printf("UQI = %f\tMSE=%f\tCorr. = %f\tSNR = %f\tSI = %f\n", recuqi, recmse, reccorr, recsnr, recsi);
}
if (dim > 0) {
imr = Tools::resampling_piximg(Xr.data(), Array2i(dcol, drow), dim, oserr);
}
// if (wlow > imr.minCoeff())
// imr = (imr<wlow).select(0, imr);
// if (whigh < imr.maxCoeff())
// imr = (imr>whigh).select(whigh, imr);
sprintf(buffer, "Reconstruction");
string rec_fname = buffer;
CmdTools::imsave(imr, inpath_fname+"/"+rec_fname);
//CmdTools::savearray(imr, inpath_fname+"/"+rec_fname);
if (verbose) {
CmdTools::imshow(imr, "Reconstruction");
}
cout<<"Outputs saved in directory "<<inpath_fname<<endl;
return 0;
}
| [
"han.wang.fr@gmail.com"
] | han.wang.fr@gmail.com |
085711c3b873e28b14d63a9bd8fb12d16b9c61ac | f14626611951a4f11a84cd71f5a2161cd144a53a | /武侠世界/代码/Common/Packets/GWRelation.cpp | b8787569b364d11b1df767618acb167538be0bc6 | [] | no_license | Deadmanovi4/mmo-resourse | 045616f9be76f3b9cd4a39605accd2afa8099297 | 1c310e15147ae775a59626aa5b5587c6895014de | refs/heads/master | 2021-05-29T06:14:28.650762 | 2015-06-18T01:16:43 | 2015-06-18T01:16:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 593 | cpp | #include "stdafx.h"
#include "stdafx.h"
#include "GWRelation.h"
BOOL GWRelation::Read( SocketInputStream& iStream )
{
__ENTER_FUNCTION
m_Relation.Read( iStream ) ;
return TRUE ;
__LEAVE_FUNCTION
return FALSE ;
}
BOOL GWRelation::Write( SocketOutputStream& oStream )const
{
__ENTER_FUNCTION
m_Relation.Write( oStream ) ;
return TRUE ;
__LEAVE_FUNCTION
return FALSE ;
}
UINT GWRelation::Execute( Player* pPlayer )
{
__ENTER_FUNCTION
return GWRelationHandler::Execute( this, pPlayer ) ;
__LEAVE_FUNCTION
return FALSE ;
}
| [
"ichenq@gmail.com"
] | ichenq@gmail.com |
a492e11a69d1bf83a7f2fd0b309c9ba6d87b0758 | 7c072be9bac76704bc83a48faa336d11c478d01f | /chapter11X_Q03e.cpp | 86f37140555e46366e9350a13fe750881b280506 | [
"MIT"
] | permissive | aliyyousuff/learncpp.com | c11dc3693097d0cccabe955929c94817ea9af606 | 1742f1ae4e431b698061840b791f4eef50fce2ee | refs/heads/main | 2023-04-26T13:55:25.808779 | 2021-05-22T06:57:02 | 2021-05-22T06:57:02 | 349,706,831 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,209 | cpp | /*
e) Now we want to be able to print our monster so we can validate it’s correct. To do that, we’re going to need to write a function
that converts a Monster::Type into a string. Write that function (called getTypeString()), as well as a print() member function.
*/
#include <iostream>
#include <string>
#include <chrono>
#include <algorithm>
#include <numeric>
#include <iterator>
#include <array>
#include <vector>
#include <string_view>
#include <functional>
#include <cmath>
#include <random>
#include <cassert>
#include <cstdint>
class Monster
{
public:
enum class Type
{
DRAGON,
GOBLIN,
OGRE,
ORC,
SKELETAN,
TROLL,
VAMPIRE,
ZOMBIE,
MAX_MONSTER_TYPES
};
Monster(Type monster, std::string name, std::string roar, int hit)
: m_type{ monster }, m_name{ name }, m_roar{ roar }, m_hit_point{ hit }
{ }
std::string_view get_type_string() const
{
switch (m_type)
{
case Type::DRAGON:
return "dragon";
case Type::GOBLIN:
return "goblin";
case Type::OGRE:
return "ogre";
case Type::ORC:
return "orc";
case Type::SKELETAN:
return "skeleton";
case Type::TROLL:
return "troll";
case Type::VAMPIRE:
return "vampire";
case Type::ZOMBIE:
return "zombie";
default:
return "???";
}
}
void print() const
{
std::cout << m_name <<" the " << get_type_string() << " has " << m_hit_point
<< " hit points and says " << m_roar << '\n';
}
private:
Type m_type{ };
std::string m_name{ };
std::string m_roar{ };
int m_hit_point{ };
};
int main()
{
Monster skeleton{ Monster::Type::SKELETAN, "Bones", "*rattle*", 4 };
skeleton.print();
return 0;
} | [
"noreply@github.com"
] | noreply@github.com |
21a6054883b026b28c4807b6e0d69b356358c1ab | 6d58fd3ce634d31f829220eded13dc02bad2fd5e | /now_in_release/massmodels/support/cosinfo.cc | 345c09600519434ebcf8356d54b791d94d95b440 | [] | no_license | HEASARC/xspec_localmodels | f0926118ce1172fe12effde360ed61f8316aa802 | cd3d09357a6fe3bcbc0f4c32407ec9f22a8ee0b3 | refs/heads/master | 2023-04-18T06:01:04.899033 | 2023-04-11T17:10:43 | 2023-04-11T17:10:43 | 126,516,606 | 7 | 7 | null | 2019-12-12T15:22:28 | 2018-03-23T17:16:13 | C | UTF-8 | C++ | false | false | 637 | cc | // Angular diameter distance and critical density
#include <iostream>
#include <cstdlib>
#include "cosbits.h"
void usage (char **argv) {
std::cerr << "Usage: " << argv[0] << " <cosmological par file> <redshift>\n";
exit (EXIT_FAILURE);
}
int main (int argc, char **argv) {
if (argc != 3)
usage (argv);
char *p;
double z = strtod (argv[2], &p);
if (p == argv[2])
usage (argv);
Cosbits cb (z, argv[1]);
std::cout.precision (12);
std::cout << "Angular diameter distance: " << cb.angulardiamd ()
<< " m\nCritical density: " << cb.rhocrit ()
<< " kg m^{-3}" << std::endl;
return EXIT_SUCCESS;
}
| [
"kristin.l.rutkowski@nasa.gov"
] | kristin.l.rutkowski@nasa.gov |
c3394d8c6c2f0dbf49f43467833170beb49af7a5 | 103ca3dacfa3d96ea624e84b05c9e945e50fa3fb | /AISandbox/Automator.cpp | 7e1ce9815174e5d2a46ac34bfbc1ec39301cceae | [] | no_license | Dizzly/AINavMesh | 58c5293277de80e3254381b215e94ea51bb9395c | b38bd2682a29de397fdbee5927816910e7cfd4f0 | refs/heads/master | 2020-05-18T15:52:15.557663 | 2015-02-11T16:08:43 | 2015-02-11T16:08:43 | 30,655,328 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 750 | cpp | #include "Automator.h"
#include "Npc.h"
Automator::Automator(Npc* p): parent_(p), target_(nullptr)
{
}
Automator::~Automator()
{}
int Automator::AddBehaviour(PBehaviour b, float w)
{
beh_.push_back(std::make_pair(b,w));
return beh_.size()-1;
}
Behaviour* Automator::GetBehaviour(int i)
{
return beh_[i].first;
}
void Automator::Update()
{
SteeringData total;
for (auto it=beh_.begin();it!=beh_.end();++it)
{
SteeringData dat;
it->first->Update(dat,it->second,target_);
total+=dat;
}
parent_->GetTransform()->AddSteeringData(total);
parent_->GetTransform()->Update();
}
GameObject* Automator::GetTarget()
{
return target_;
}
void Automator::SetTarget(pGameObject t)
{
target_=t;
} | [
"aldocurtis@gmail.com"
] | aldocurtis@gmail.com |
7ddcd4838de5d9fa885ad6888e306a3ce42a361c | bac0d4fa74ca5eaa7d42d64474ccc4f444196eaa | /C++/project/cpp_projects/09th_operator/point2_1.cpp | af9bac03f25455c85d816ad92b6576e9f78c257a | [] | no_license | zhuhaijun753/autosar-1 | e3658b087c8d18bd546963a556bf4c247591cd1b | 8b34d3b6a38247b81a56b80d15adfe694b9304b8 | refs/heads/master | 2020-07-25T10:49:20.732125 | 2019-06-17T13:09:46 | 2019-06-17T13:09:46 | 208,263,900 | 1 | 2 | null | 2019-09-13T12:51:12 | 2019-09-13T12:51:12 | null | UTF-8 | C++ | false | false | 1,247 | cpp | #include <iostream>
#include <string.h>
#include <unistd.h>
using namespace std;
class Point {
private:
int x;
int y;
public:
Point() {}
Point(int x, int y) : x(x), y(y) {}
int getX(){ return x; }
int getY(){ return y; }
void setX(int x){ this->x = x; }
void setY(int y){ this->y = y; }
void printInfo()
{
cout<<"("<<x<<", "<<y<<")"<<endl;
}
friend Point add(Point &p1, Point &p2);
friend Point operator+(Point &p1, Point &p2);
friend Point operator++(Point &p);
friend Point operator++(Point &p, int a);
};
Point add(Point &p1, Point &p2)
{
Point n;
n.x = p1.x+p2.x;
n.y = p1.y+p2.y;
return n;
}
Point operator+(Point &p1, Point &p2)
{
cout<<"Point operator+(Point &p1, Point &p2)"<<endl;
Point n;
n.x = p1.x+p2.x;
n.y = p1.y+p2.y;
return n;
}
/* Point p(1,2); ++p; */
Point operator++(Point &p, int a)
{
cout<<"++p"<<endl;
p.x += 1;
p.y += 1;
return p;
}
/* Point p(1,2); p++; */
Point operator++(Point &p)
{
cout<<"p++"<<endl;
Point n;
n = p;
p.x += 1;
p.y += 1;
return n;
}
int main(int argc, char **argv)
{
Point p1(1, 2);
Point p2(2, 3);
Point n = ++p1;
n.printInfo();
p1.printInfo();
cout << "******************"<<endl;
Point m = p2++;
m.printInfo();
p2.printInfo();
return 0;
}
| [
"346067259@qq.com"
] | 346067259@qq.com |
0348d1bd066309ff40c1fdeb15eefd8b14b4a6cc | 3c4d46165b90abd05f3fdf48f0f86f729c10b4e3 | /算法竞赛进阶指南/例题/0x40 数据结构进阶/0x48 可持久化数据结构/K-th Number/std_树套树_bzoj1901_带修改.cpp | 89196dfb631973fac51469dcfa9e5bc1765d0a7b | [] | no_license | JK-Lix/Algorithm | 565c159fdd56c41dee9d7c08a72987a206357bfa | ae57578ddba4019841a6595e53417778582110b5 | refs/heads/master | 2020-05-09T16:44:23.831663 | 2019-06-22T11:55:59 | 2019-06-22T11:55:59 | 181,271,742 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,340 | cpp | #include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int inf=1000000000;
struct tree{int l,r,dat,size;}t[40010],a[1000010];
int L[10010],R[10010],p[40010],b[10010],n,m,tot,i,l,r,k,x,y,z;
char str[2];
inline void update(int x)
{
a[x].size=a[a[x].l].size+a[a[x].r].size+1;
}
void zag(int &x)
{
int y=a[x].r; a[x].r=a[y].l; a[y].l=x;
update(x); update(y); x=y;
}
void zig(int &x)
{
int y=a[x].l; a[x].l=a[y].r; a[y].r=x;
update(x); update(y); x=y;
}
void comb(int &x)
{
L[L[0]+1]=a[x].l; R[R[0]+1]=a[x].r;
for(int i=L[0];i>0;i--) {a[L[i]].r=L[i+1]; update(L[i]);}
for(int i=R[0];i>0;i--) {a[R[i]].l=R[i+1]; update(R[i]);}
a[x].l=L[1]; a[x].r=R[1]; update(x);
}
void get(int &x,int y)
{
if(!x) return;
L[0]=R[0]=0;
while(1)
{
if(y==a[x].dat||(y<a[x].dat&&!a[x].l)||(y>a[x].dat&&!a[x].r)) break;
if(y<a[x].dat)
{
if(y<a[a[x].l].dat) {zig(x); if(!a[x].l) break;}
R[++R[0]]=x; x=a[x].l;
}
else{
if(y>a[a[x].r].dat) {zag(x); if(!a[x].r) break;}
L[++L[0]]=x; x=a[x].r;
}
}
comb(x);
}
void splay(int &x,int y)
{
if(!x) return;
L[0]=R[0]=0;
while(1)
{
int temp=a[a[x].l].size+1;
if(y==temp||(y<temp&&!a[x].l)||(y>temp&&!a[x].r)) break;
if(y<temp)
{
if(a[a[x].l].l&&y<=a[a[a[x].l].l].size) {zig(x); if(!a[x].l) break;}
R[++R[0]]=x; x=a[x].l;
}
else{
y-=temp;
temp=a[a[a[x].r].l].size+1;
if(a[a[x].r].r&&y>temp) {y-=temp; zag(x); if(!a[x].r) break;}
L[++L[0]]=x; x=a[x].r;
}
}
comb(x);
}
void ins(int &x,int y)
{
a[++tot].dat=y; a[tot].size=1;
get(x,y);
if(a[x].dat<=y)
{
splay(a[x].r,1);
a[a[x].r].l=tot;
update(a[x].r); update(x);
}
else{
splay(a[x].l,a[a[x].l].size);
a[a[x].l].r=tot;
update(a[x].l); update(x);
}
}
void del(int &x,int y)
{
get(x,y);
splay(a[x].r,1);
a[a[x].r].l=a[x].l;
x=a[x].r;
update(x);
}
void buildsplay(int num)
{
p[num]=++tot; a[tot].r=tot+1;
a[tot].dat=-inf; a[tot].size=2;
a[++tot].dat=inf; a[tot].size=1;
for(int i=t[num].l;i<=t[num].r;i++) ins(p[num],b[i]);
}
void build(int num,int l,int r)
{
t[num].l=l; t[num].r=r; t[num].dat=b[l];
buildsplay(num);
if(l==r) return;
int mid=(l+r)>>1;
build(num*2,l,mid);
build(num*2+1,mid+1,r);
}
void change(int num)
{
if(t[num].l==t[num].r)
{
z=t[num].dat; t[num].dat=y;
del(p[num],z);
ins(p[num],y);
return;
}
int mid=(t[num].l+t[num].r)>>1;
if(x<=mid) change(num*2); else change(num*2+1);
del(p[num],z);
ins(p[num],y);
}
int ask(int num)
{
if(x<=t[num].l&&y>=t[num].r)
{
get(p[num],k);
splay(a[p[num]].r,1);
while(a[p[num]].dat==k&&a[a[p[num]].r].dat==k)
{
zag(p[num]);
splay(a[p[num]].r,1);
}
if(a[p[num]].dat<=k) return a[a[p[num]].l].size;
else return a[a[p[num]].l].size-1;
}
int mid=(t[num].l+t[num].r)>>1,temp=0;
if(x<=mid) temp+=ask(num*2);
if(y>mid) temp+=ask(num*2+1);
return temp;
}
int main()
{
cin>>n>>m;
for(i=1;i<=n;i++) scanf("%d",&b[i]);
build(1,1,n);
for(i=1;i<=m;i++)
{
scanf("%s%d%d",str,&x,&y);
if(str[0]=='Q')
{
scanf("%d",&z);
l=0; r=inf;
while(l<r)
{
k=(l+r)>>1;
if(ask(1)<z) l=k+1;else r=k;
}
printf("%d\n",l);
}
else change(1);
}
return 0;
} | [
"776579471@qq.com"
] | 776579471@qq.com |
551e4dc8cba2396557b384a6ca61f14fb0326f5c | e16b04c283e0d5ed568aa5152597440f740a4bbb | /src/cxx/astro/weaklensing/mainwl/gamma_to_kappa.cc | 8cbdcdfb31790db0a0666e82b38c6e658c6fe44c | [
"MIT"
] | permissive | jstarck/cosmostat | 58187ccd3bd79db665b487998e1098c932058aea | f686efe4c00073272487417da15e207a529f07e7 | refs/heads/master | 2022-12-11T19:47:09.329007 | 2020-07-06T16:11:59 | 2020-07-06T16:11:59 | 277,772,870 | 0 | 0 | MIT | 2020-07-07T09:23:50 | 2020-07-07T09:23:50 | null | UTF-8 | C++ | false | false | 4,762 | cc | /******************************************************************************
** Copyright (C) 2013 by CEA
*******************************************************************************
**
** UNIT
**
** Version: 1.0
**
** Author: Francois Lanusse
**
** Date: 13/12/01
**
** File: pkrec.cpp
**
*******************************************************************************
**
** DESCRIPTION Primordial power spectrum reconstruction using sparsity
** -----------
**
** PARAMETRES
** ----------
**
** RESULTS
** -------
**
**
******************************************************************************/
#include "IM_Obj.h"
#include "IM_IO.h"
#include <iostream>
#include "shearinversions.h"
#define DEF_ZERO_PAD 512
char Name_gamma[100];
char Name_kappaE[100];
char Name_kappaB[100];
int Zero_pad = DEF_ZERO_PAD;
Bool Reverse=False;
extern int OptInd;
extern char *OptArg;
extern int GetOpt(int argc, char *const*argv, char *opts);
/*********************************************************************/
static void usage(char *argv[])
{
fprintf(OUTMAN, "Usage: %s options gamma_in kappaE_out \n\n", argv[0]);
fprintf(OUTMAN, " where options = \n");
fprintf(OUTMAN, " [-Z ZeroPad]\n");
fprintf(OUTMAN, " Size of the zero padding \n");
fprintf(OUTMAN, " default is %d\n", DEF_ZERO_PAD);
manline();
fprintf(OUTMAN, " [-r \n");
fprintf(OUTMAN, " Do the reverse, i.e. kappa_to_gamma. \n");
manline();
vm_usage();
manline();
verbose_usage();
manline();
manline();
exit(-1);
}
/*********************************************************************/
/* GET COMMAND LINE ARGUMENTS */
static void infinit(int argc, char *argv[])
{
int c;
#ifdef LARGE_BUFF
int VMSSize=-1;
Bool OptZ = False;
char VMSName[1024] = "";
#endif
/* get options */
while ((c = GetOpt(argc,argv,"?:rZ:")) != -1)
{
switch (c)
{
case 'Z':
/* -Z < zero padding size > */
if (sscanf(OptArg,"%d",&Zero_pad) != 1) {
fprintf(OUTMAN, "bad Zero padding argument: %s\n", OptArg);
usage(argv);
}
if (Zero_pad <= 0) Zero_pad = DEF_ZERO_PAD;
break;
case 'r': Reverse=True;break;
case '?': usage(argv); break;
default: usage(argv); break;
}
}
if (OptInd < argc) strcpy(Name_gamma, argv[OptInd++]);
else usage(argv);
if (OptInd < argc) strcpy(Name_kappaE, argv[OptInd++]);
else usage(argv);
/* make sure there are not too many parameters */
if (OptInd < argc)
{
fprintf(OUTMAN, "Too many parameters: %s ...\n", argv[OptInd]);
usage(argv);
}
#ifdef LARGE_BUFF
if (OptZ == True) vms_init(VMSSize, VMSName, Verbose);
#endif
}
int main(int argc, char **argv) {
char Cmd[512];
Cmd[0] = '\0';
for (int k =0; k < argc; k++) sprintf(Cmd, "%s %s", Cmd, argv[k]);
/* Get command line arguments, open input file(s) if necessary */
infinit(argc, argv);
if (Reverse == False)
{
fltarray gammaIn;
fits_read_fltarr(Name_gamma,gammaIn);
int Nx = gammaIn.nx();
int Ny = gammaIn.ny();
dblarray gamma1(Nx,Ny);
dblarray gamma2(Nx,Ny);
dblarray kappaDbl(Nx,Ny);
fltarray kappa_out(Nx,Ny);
for(int x=0; x < Nx; x++)
for(int y=0; y < Ny; y++){
gamma1(x,y) = gammaIn(x,y,0);
gamma2(x,y) = gammaIn(x,y,1);
}
ShearInversions inv(max(Zero_pad,max(Nx,Ny)));
inv.gamma2kappa(gamma1,gamma2,kappaDbl);
for(int x=0; x < Nx; x++)
for(int y=0; y < Ny; y++){
kappa_out(x,y) = kappaDbl(x,y);
}
fits_write_fltarr(Name_kappaE,kappa_out);
}
else
{
fltarray kappa_in;
fits_read_fltarr(Name_gamma,kappa_in);
int Nx = kappa_in.nx();
int Ny = kappa_in.ny();
dblarray gamma1(Nx,Ny);
dblarray gamma2(Nx,Ny);
dblarray kappaDbl(Nx,Ny);
fltarray gammaOut(Nx,Ny,2);
for(int x=0; x < Nx; x++)
for(int y=0; y < Ny; y++){
kappaDbl(x,y) = kappa_in(x,y);
}
ShearInversions inv(max(Zero_pad,max(Nx,Ny)));
inv.kappa2gamma(kappaDbl,gamma1,gamma2);
for(int x=0; x < Nx; x++)
for(int y=0; y < Ny; y++){
gammaOut(x,y,0) = gamma1(x,y);
gammaOut(x,y,1) = gamma2(x,y);
}
fits_write_fltarr(Name_kappaE,gammaOut);
}
return 0;
}
| [
"jstarck@cea.fr"
] | jstarck@cea.fr |
629fb171a42310c0c5d58450a1f07dec65db8a62 | 4cc2d44a8367a793e98eae7c988b65d42cb202ba | /atcoder/abc124/D.cpp | 188725aa2b0f9f15a51d106594ba5c732a5fddb8 | [] | no_license | nojima/workspace | f0456633d0aeb620d9858a60ffc50178ec752d01 | 3d76242df8ae70fd8d38c5a0dac84a8ff13c7557 | refs/heads/master | 2023-03-05T21:12:36.888289 | 2023-03-04T16:31:46 | 2023-03-04T16:33:11 | 100,114,101 | 3 | 0 | null | 2023-03-04T06:45:12 | 2017-08-12T13:30:00 | JavaScript | UTF-8 | C++ | false | false | 948 | cpp | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
int main() {
int N, K;
while (cin >> N >> K) {
string S; cin >> S;
vector<int> n_segment(N);
bool in_segment = (S[0] == '0');
n_segment[0] = (S[0] == '0');
for (int i = 1; i < N; ++i) {
if (S[i] == '0') {
n_segment[i] = n_segment[i-1] + (in_segment ? 0 : 1);
in_segment = true;
} else {
n_segment[i] = n_segment[i-1];
in_segment = false;
}
}
int answer = 0;
for (int i = 0; i < N; ++i) {
int limit = K + n_segment[i] + (S[i] == '0' ? -1 : 0);
auto it = upper_bound(n_segment.begin() + i, n_segment.end(), limit);
int len = it - (n_segment.begin() + i);
answer = max(answer, len);
}
cout << answer << endl;
}
} | [
"nojima@ynojima.com"
] | nojima@ynojima.com |
92a2ec9c610c8c26b032fd71f4046582ddc6a03a | f72afecda17f6b946672b119710ee10a09839590 | /main.cpp | 75099af6b0e74aaad2fa47ff58c83bb68e34196b | [] | no_license | ChromatiCat/OpenGL-Light-Effect | 911a6fd54ad4e45e650e23b371a9c9d040cf6ffb | f7b99756ccfc0c56ec34fabe1b33f8dd1f1795f2 | refs/heads/master | 2020-04-07T23:02:02.317995 | 2018-11-23T07:25:23 | 2018-11-23T07:25:23 | 158,795,273 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 8,392 | cpp | #include "include/Angel.h"
#include "include/TriMesh.h"
#pragma comment(lib, "glew32.lib")
#include <cstdlib>
#include <iostream>
using namespace std;
GLuint programID;
GLuint vertexArrayID;
GLuint vertexBufferID;
GLuint vertexNormalID;
GLuint vertexIndexBuffer;
GLuint vPositionID;
GLuint vNormalID;
GLuint viewMatrixID;
GLuint viewProjMatrixID;
GLuint modelMatrixID;
GLuint shadowFlagID;
GLuint lightPosID;
// 相机参数
float radius = 2.0;
float rotateAngle = 0.0;
float upAngle = 45;
// 正交投影参数
float scale = 1.0;
float n = 0.1, f = 10;
TriMesh* mesh = new TriMesh();
float lightPos[3] = { 2.0, 2.0, 2.0 };
//////////////////////////////////////////////////////////////////////////
// 相机
namespace Camera
{
//正交投影变换
mat4 ortho(const GLfloat left, const GLfloat right,
const GLfloat bottom, const GLfloat top,
const GLfloat zNear, const GLfloat zFar)
{
mat4 c;
c[0][0] = 2 / (right - left);
c[1][1] = 2 / (top - bottom);
c[2][2] = -2 / (zFar - zNear);
c[3][0] = (right + left) / (left - right);
c[3][1] = (top + bottom) / (bottom - top);
c[3][2] = (zFar + zNear) / (zNear - zFar);
c[3][3] = 1;
return c;
}
//透视投影变换
mat4 perspective(const GLfloat fovy, const GLfloat aspect,
const GLfloat zNear, const GLfloat zFar)
{
GLfloat top = tan(fovy*DegreesToRadians / 2) * zNear;
GLfloat right = top * aspect;
mat4 c;
c[0][0] = zNear / right;
c[1][1] = zNear / top;
c[2][2] = -(zFar + zNear) / (zFar - zNear);
c[2][3] = (-2.0*zFar*zNear) / (zFar - zNear);
c[3][2] = -1.0;
c[3][3] = 0.0;
return c;
}
//观察变换
mat4 lookAt(const vec4& eye, const vec4& at, const vec4& up)
{
vec4 n(normalize(eye - at));
vec4 u(normalize(cross(up, n)), 0);
vec4 v(normalize(cross(n, u)), 0);
return mat4(u, v, n, vec4(0.0, 0.0, 0.0, 1.0))* Translate(-eye);
}
mat4 modelMatrix(1.0);
mat4 viewMatrix(1.0);
mat4 projMatrix(1.0);
}
//////////////////////////////////////////////////////////////////////////
// OpenGL 初始化
void init()
{
glClearColor(0.8f, 0.8f, 0.8f, 1);
programID = InitShader("vshader_frag.glsl", "fshader_frag.glsl");
// 从顶点着色器和片元着色器中获取变量的位置
vPositionID = glGetAttribLocation(programID, "vPosition");
vNormalID = glGetAttribLocation(programID, "vNormal");
viewMatrixID = glGetUniformLocation(programID, "viewMatrix");
viewProjMatrixID = glGetUniformLocation(programID, "viewProjMatrix");
modelMatrixID = glGetUniformLocation(programID, "modelMatrix");
lightPosID = glGetUniformLocation(programID, "lightPos");
shadowFlagID = glGetUniformLocation(programID, "isShadow");
// 读取外部三维模型
mesh->read_off("sphere.off");
vector<vec3f> vs = mesh->v();
vector<vec3i> fs = mesh->f();
vector<vec3f> ns;
//由于模型在原坐标系中圆心在原点，在此将其平移到y=0平面以上
vec3f buttom = vs[0];
for (int i = 0; i < vs.size(); ++i)
if (vs[i].y < buttom.y) buttom = vs[i];
for (int i = 0; i < vs.size(); ++i)
{
vs[i].y = vs[i].y - buttom.y;
ns.push_back(normalize(vs[i] - vec3(0.0, -buttom.y, 0.0)));
}
// 生成VAO
glGenVertexArrays(1, &vertexArrayID);
glBindVertexArray(vertexArrayID);
// 生成VBO，并绑定顶点数据
glGenBuffers(1, &vertexBufferID);
glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
glBufferData(GL_ARRAY_BUFFER, vs.size() * sizeof(vec3f), vs.data(), GL_STATIC_DRAW);
// 生成VBO，并绑定法向量数据
glGenBuffers(1, &vertexNormalID);
glBindBuffer(GL_ARRAY_BUFFER, vertexNormalID);
glBufferData(GL_ARRAY_BUFFER, ns.size() * sizeof(vec3f), ns.data(), GL_STATIC_DRAW);
// 生成VBO，并绑定顶点索引
glGenBuffers(1, &vertexIndexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexIndexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, fs.size() * sizeof(vec3i), fs.data(), GL_STATIC_DRAW);
// OpenGL相应状态设置
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_CULL_FACE);
}
//////////////////////////////////////////////////////////////////////////
// 渲染
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(programID);
// 计算观察变换矩阵
float eyex = radius*sin(rotateAngle*DegreesToRadians)*cos(upAngle*DegreesToRadians);
float eyey = radius*sin(upAngle*DegreesToRadians);
float eyez = radius*cos(rotateAngle*DegreesToRadians)*cos(upAngle*DegreesToRadians);
vec4 eye(eyex,eyey,eyez, 1.0); // 光源关于y-z平面的对称方向
vec4 at(0, 0, 0, 1); // 原点
vec4 up(0, 1, 0, 0); // 默认方向
Camera::viewMatrix = Camera::lookAt(eye, at, up);
// 计算阴影变换矩阵
float lx = lightPos[0];
float ly = lightPos[1];
float lz = lightPos[2];
mat4 shadowProjMatrix
(-ly, 0.0, 0.0, 0.0,
lx, 0.0, lz, 1.0,
0.0, 0.0, -ly, 0.0,
0.0, 0.0, 0.0, -ly);
Camera::modelMatrix = shadowProjMatrix;
// 计算投影变换矩阵
Camera::projMatrix= Camera::ortho(-scale, scale, -scale, scale, n, f);
// 将对应矩阵传入着色器
mat4 viewProjMatrix = Camera::projMatrix * Camera::viewMatrix;
glUniformMatrix4fv(modelMatrixID, 1, GL_TRUE, Camera::modelMatrix);
glUniformMatrix4fv(viewMatrixID, 1, GL_TRUE, Camera::viewMatrix);
glUniformMatrix4fv(viewProjMatrixID, 1, GL_TRUE, viewProjMatrix);
// 将光源位置传入顶点着色器
glUniform3fv(lightPosID, 1, lightPos);
glEnableVertexAttribArray(vPositionID);
glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
glVertexAttribPointer(
vPositionID,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0
);
glEnableVertexAttribArray(vNormalID);
glBindBuffer(GL_ARRAY_BUFFER, vertexNormalID);
glVertexAttribPointer(
vNormalID,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0
);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexIndexBuffer);
// 设置阴影标志变量为1，并绘制阴影(若光源位于球心水平下方则不绘制)
if (lightPos[1] > 0) {
glUniform1i(shadowFlagID, 1);
glDrawElements(
GL_TRIANGLES,
int(mesh->f().size() * 3),
GL_UNSIGNED_INT,
(void*)0
);
}
// 设置阴影标志变量为0，更改modelMatrix为单位矩阵，并绘制球体
glUniform1i(shadowFlagID, 0);
Camera::modelMatrix = mat4(1.0);
glUniformMatrix4fv(modelMatrixID, 1, GL_TRUE, Camera::modelMatrix);
glDrawElements(
GL_TRIANGLES,
int(mesh->f().size() * 3),
GL_UNSIGNED_INT,
(void*)0
);
glDisableVertexAttribArray(vPositionID);
glUseProgram(0);
glutSwapBuffers();
}
//////////////////////////////////////////////////////////////////////////
// 重新设置窗口
void reshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
}
//////////////////////////////////////////////////////////////////////////
// 鼠标响应函数：控制光源位置
void mouse( int x, int y)
{
lightPos[0] = x - 250;
lightPos[1] = 250 - y;
glutPostRedisplay();
}
//////////////////////////////////////////////////////////////////////////
// 键盘响应函数
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 033: // ESC键 和 'q' 键退出游戏
exit(EXIT_SUCCESS);
break;
case 'q':
exit(EXIT_SUCCESS);
break;
case 'w'://w和s控制观察的俯仰角度
upAngle += 0.1;
break;
case 's':
upAngle -= 0.1;
}
glutPostRedisplay();
}
//////////////////////////////////////////////////////////////////////////
void idle(void)
{
glutPostRedisplay();
}
//////////////////////////////////////////////////////////////////////////
void clean()
{
glDeleteBuffers(1, &vertexBufferID);
glDeleteProgram(programID);
glDeleteVertexArrays(1, &vertexArrayID);
if (mesh) {
delete mesh;
mesh = NULL;
}
}
//////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowSize(500, 500);
glutCreateWindow("黄俊粤_2016150107_实验三");
glewInit();
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMotionFunc(mouse);
glutKeyboardFunc(keyboard);
glutIdleFunc(idle);
glutMainLoop();
clean();
return 0;
} | [
"noreply@github.com"
] | noreply@github.com |
2e4e2664b5b6d3027e4753d1aeac85804ac112ec | 54259eba648bac406aaead5474d8f105bc011e36 | /checkerboard.cpp | 0a212449fb08be5c98b094c0ca5a8dc62ea40c91 | [] | no_license | RafaPeralva/csci_hunter | 98100b192148e48d8aba464ac9fc21d8dfac4ff5 | 7e0ab2f101677dcb017a3b56c5fd6bbf7ac68d34 | refs/heads/master | 2020-08-31T02:09:04.945067 | 2019-10-30T15:26:16 | 2019-10-30T15:26:16 | 218,554,068 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,226 | cpp | /*
Author: Rafaela Peralva
Course: CSCI-136
Instructor: Subhadarshi Panda
Assignment: lab 4B
asks user for width and heigh and then prints a checkerboard
*/
#include <iostream>
using namespace std;
int main()
{
int w;
int h;
int len=0;
string space = "";
cout<<"Enter a width: "<<endl; //enters a number
cin>> w;
cout<<"Enter height: "<< endl;
cin>>h;
char star='*';
for (int i=0; i<h; i++)
{
if (w%2==0){
if (i%2==0){
for(int a=0; a<w/2; a++){
cout<<star;
cout<<" ";
}
}
else{
for (int a=0; a<w/2; a++){
cout<<" ";
cout<<star;
}
}
cout<<endl;
}
else{
if (i%2==0){
for(int a=0; a<(w/2)+1; a++){
cout<<star;
cout<<" ";
}
}
else{
for (int a=0; a<(w/2); a++){
cout<<" ";
cout<<star;
}
}
cout<<endl;
}
}
//cout<<space;
//w-=2;
cout<<endl; //sets up for a new line
//len++;
//space+=" ";
//i--;
}
| [
"rafaelaperalva@hotmail.com"
] | rafaelaperalva@hotmail.com |
87e9f17078e70ddda6c24d946e85dfe6c7bda969 | ab686eb3a176b5845919d80c66662f94624ecc05 | /Company Specific/Amazon SDET/Heap/shortest subarray with sum atleast k.cpp | df395024debfaea67a8c6946b41c5f5eec4e4cd4 | [] | no_license | chiragasawa/interview-prep | 341be6be58159a75b91c3ca3ec572c371a7c2caf | 0200ba04d9cc46f04c33f20276b77f49825ea091 | refs/heads/main | 2023-09-03T07:59:09.658756 | 2021-10-19T05:16:44 | 2021-10-19T05:16:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 865 | cpp | class Solution {
public:
int shortestSubarray(vector<int>& nums, int k) {
priority_queue<pair<int,int>, vector< pair<int,int>>, greater<pair<int,int>>>pq;
int sum = 0;
int ans = INT_MAX;
auto n = nums.size();
for(int i = 0 ; i < n ; ++i){
sum = sum + nums[i];
if(sum >= k){
ans = min(ans , i + 1);
}
while(pq.size() and sum - pq.top().first >= k){
auto &t = pq.top();
ans = min(ans , i - t.second);
pq.pop();
}
pq.push({sum , i});
}
if(ans == INT_MAX) return -1;
return ans;
}
};
| [
"noreply@github.com"
] | noreply@github.com |
46d579555f2f360f0ea2bb3addc988f86346c41b | 495a7a0a9b074978e2c51a944de9d1fcb81c24cc | /1.5 Classes/friend_class.cpp | f8f7842a3f433a4f3adab12efdbd21d60720e40b | [] | no_license | rishabh-997/OOP-s-Lab-Assignments | a4920edad3883171117d4a0b1e3fb9b8cb3096da | b9ae21fb92f65668c8af081064709d2faa5d0d25 | refs/heads/master | 2021-10-09T17:57:46.480732 | 2021-10-01T20:05:43 | 2021-10-01T20:05:43 | 208,182,997 | 0 | 4 | null | 2021-10-01T20:05:43 | 2019-09-13T02:37:10 | C++ | UTF-8 | C++ | false | false | 1,158 | cpp | #include<bits/stdc++.h>
using namespace std;
/**
-----------------------------Class Friends and Class Members-----------------------------------------
1. Complex data structures typically involves the interaction of many classes.
2. in such cases, there are often issues in coordinating the actions of these classes to allow sharing of these information.
3. we can declare a function as friend, this means this member can access the classes of private data.
4. another time when it is appropriate to use friends is when two different classes are closely related.
*/
class someclass{
private:
int secret;
public:
friend ostream& operator << (ostream& out, const someclass & x){
cout<<x.secret<<endl;
}
};
class Vector{
private:
double cordi[3];
friend class Matrix;
public:
};
class Matrix{
private:
double arr[3][3];
public:
Vector multiply (const Vector& v){
}
};
Vector Matrix::multiply (const Vector & v){
Vector w;
for(int i=0;i<3;i++){
w.cordi[i] = 0;
for(int j =0; j<3 ;j++)
w.cordi[i] += arr[i][j] * v.cordi[j];
}
}
int main(){
someclass a;
}
| [
"rishabh.agarwal997@gmail.com"
] | rishabh.agarwal997@gmail.com |
35d4bf2c769c65c66e1a0acd9cbc0966d8907309 | caa91484865db24d21c807abc999ba4dc471e186 | /zrm/zrmbasewidget.h | 795148aadd287cc7d24eb88a2a44d55261cb88fa | [] | no_license | dostapazov/powermon | 351a9a6aa670fcb598142c514824dbdbbc03d24f | 8d619a20e195e90a5147d7e39d4ea254cfbe6e39 | refs/heads/master | 2021-07-11T23:00:07.172403 | 2020-10-13T15:55:03 | 2020-10-13T15:55:03 | 206,970,465 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,977 | h | /* Ostapenko D. V.
* NIKTES 2019-03-22
* Base widget for display state channel of zrm
*
*/
#ifndef ZRMBASEWIDGET_H
#define ZRMBASEWIDGET_H
#include <qwidget.h>
#include <qtextcodec.h>
#include <zrm_connectivity.hpp>
#include <qlabel.h>
#include <qspinbox.h>
#include <qicon.h>
// Timer for simultaneous flashing objects
class ZrmFlashTimer:public QObject
{
Q_OBJECT
public:
ZrmFlashTimer(QObject * parent = Q_NULLPTR);
void start_flash();
void stop_flash ();
bool is_flash_on();
signals:
void flash(bool flash_on);
private slots:
void on_timeout();
private:
int m_flash_state = 0;
QTimer m_timer;
};
class ZrmBaseWidget:public QWidget
{
Q_OBJECT
friend class ZrmGroupWidget;
public:
ZrmBaseWidget(QWidget *parent);
virtual ~ZrmBaseWidget() ;
zrm::ZrmConnectivity* connectivity(){return m_source;}
virtual void bind(zrm::ZrmConnectivity * src, uint16_t chan, bool _connect_signals = true);
bool load_ui(const QString & ui_file);
uint16_t channel() {return m_channel;}
QString channel_name(uint16_t channel);
bool channel_is_stopped (uint16_t channel);
bool channel_is_executing(uint16_t channel);
bool channel_is_paused (uint16_t channel);
static QLatin1String codec_name();
static void set_codec_name (const QLatin1String &str);
static QString to_utf(const char * str, int len);
static QTextCodec * codec();
QVariant param_get ( uint16_t channel, zrm::zrm_param_t param) {return (m_source && channel) ? m_source->param_get(channel, param) : QVariant();}
protected slots:
void slot_connected ( bool conn_state);
void slot_recv_packet ( QByteArray packet );
void slot_send_packet ( QByteArray packet );
void slot_ioerror ( QString error_string );
void slot_param_changes (unsigned channel, zrm::params_list_t params_list);
void slot_source_destroyed(QObject * obj);
protected:
virtual void connect_signals (zrm::ZrmConnectivity * conn_obj, bool conn);
virtual void source_destroyed (zrm::ZrmConnectivity * src);
virtual void on_connected (bool con_state);
virtual void on_ioerror (const QString & error_string);
virtual void channel_recv_packet (unsigned channel, const zrm::recv_header_t *recv_data);
virtual void channel_send_packet (unsigned channel, const zrm::send_header_t * send_data);
virtual void channel_param_changed(unsigned channel, const zrm::params_list_t & params_list );
virtual void update_controls ();
virtual void clear_controls (){}
virtual void channel_session (unsigned ch_num) ;
virtual void init_ui(QWidget * widget ){Q_UNUSED(widget)}
QString zrm_method_duration_text(const zrm::zrm_method_t & method);
template <typename T>
static void set_number_value (T * text_widget, double value, int precision, const QString &zero_replace = QString()) ;
template <typename T>
static void set_number_value (T * text_widget, int value, int width, const QString &zero_replace = QString());
static QString number_text( double value, int precision);
static QString number_text(int value,int width, int base = 10);
template<typename T>
static void set_icon(T * label,const QIcon * icon);
zrm::ZrmConnectivity * m_source = Q_NULLPTR;
uint16_t m_channel = 0;
static QLatin1String m_codec_name ;
static QTextCodec *m_text_codec ;
static QString infinity_symbol;
static QString no_value;
static ZrmFlashTimer flash_timer;
};
class ZrmChannelWidget:public ZrmBaseWidget
{
Q_OBJECT
public:
ZrmChannelWidget (QWidget * parent):ZrmBaseWidget(parent){}
QVariant param_get (zrm::zrm_param_t param) {return ZrmBaseWidget::param_get(uint16_t(channel()),param);}
bool is_stopped ();
bool is_paused ();
bool is_executing();
protected:
};
class ZrmGroupWidget : public ZrmBaseWidget
{
Q_OBJECT
public:
ZrmGroupWidget(QWidget * parent):ZrmBaseWidget(parent){}
virtual void bind(zrm::ZrmConnectivity * src,uint16_t chan, bool _connect_signals = true) override;
QList<ZrmBaseWidget*> zrm_widgets(){if(!m_widgets.count()){zrm_widgets_make();} return m_widgets;}
protected:
virtual void channel_recv_packet (unsigned channel, const zrm::recv_header_t * recv_data) override;
virtual void channel_send_packet (unsigned channel, const zrm::send_header_t * send_data) override;
virtual void channel_param_changed(unsigned channel, const zrm::params_list_t & params_list) override;
virtual void on_connected (bool con_state) override;
virtual void on_ioerror (const QString & error_string) override;
virtual void source_destroyed (zrm::ZrmConnectivity * src) override;
virtual void update_controls () override;
virtual void clear_controls () override;
void zrm_widgets_clear ();
void zrm_widgets_make ();
QList<ZrmBaseWidget*> m_widgets;
};
/**/
inline bool ZrmBaseWidget::channel_is_stopped (uint16_t channel)
{
return m_source && channel ? m_source->channel_is_stopped(channel) : true;
}
inline bool ZrmBaseWidget::channel_is_executing(uint16_t channel)
{
return m_source && channel ? m_source->channel_is_executing(channel) : false;
}
inline bool ZrmBaseWidget::channel_is_paused (uint16_t channel)
{
return m_source && channel ? m_source->channel_is_paused(channel) : false;
}
inline QString ZrmBaseWidget::to_utf(const char * str, int len)
{
return m_text_codec ? m_text_codec->toUnicode(str, len) : QString::fromLocal8Bit(str,len);
}
inline QLatin1String ZrmBaseWidget::codec_name()
{
return m_codec_name;
}
inline QTextCodec * ZrmBaseWidget::codec()
{
return m_text_codec;
}
template<typename T>
void ZrmBaseWidget::set_icon(T * t,const QIcon * icon)
{
t->setPixmap(icon ? icon->pixmap(t->size()) : QPixmap());
}
template <typename T>
void ZrmBaseWidget::set_number_value (T * text_widget, int value,int width, const QString &zero_replace )
{
if(text_widget)
{
if(!value && !zero_replace.isEmpty())
text_widget->setText(zero_replace);
else
text_widget->setText(number_text(value, width,10));
}
}
template <typename T>
void ZrmBaseWidget::set_number_value (T * text_widget, double value, int precision, const QString &zero_replace)
{
if(text_widget)
{
if(qFuzzyIsNull(value) && !zero_replace.isEmpty())
text_widget->setText(zero_replace);
else
text_widget->setText(number_text(value, precision));
}
}
template <>
inline void ZrmBaseWidget::set_number_value<QDoubleSpinBox> (QDoubleSpinBox * text_widget, double value, int precision, const QString &zero_replace)
{
text_widget->setSpecialValueText(zero_replace);
text_widget->setDecimals(precision);
text_widget->setValue(value);
}
inline bool ZrmChannelWidget::is_stopped ()
{
return m_source && m_channel ? m_source->channel_is_stopped(uint16_t(m_channel)) : true;
}
inline bool ZrmChannelWidget::is_paused ()
{
return m_source && m_channel ? m_source->channel_is_paused(uint16_t(m_channel)) : true;
}
inline bool ZrmChannelWidget::is_executing()
{
return m_source && m_channel ? m_source->channel_is_executing(uint16_t(m_channel)) : true;
}
#endif // ZRMBASEWIDGET_H
| [
"dostapazov@gmail.com"
] | dostapazov@gmail.com |
8529c79c57c9eb8ea3937c18409b6251673a3e3a | 91a882547e393d4c4946a6c2c99186b5f72122dd | /Source/XPSP1/NT/windows/advcore/rcml/rcmlex/speechhook/spchhk/rcmllistens.cpp | 50b29ff60b856ab23ccace5cd486fa7c0d98f999 | [] | 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 | UTF-8 | C++ | false | false | 12,492 | cpp | // RCMLListens.cpp: implementation of the CRCMLListens class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "RCMLListens.h"
#include "rcml.h"
#include "debug.h"
// #include "commctrl.h"
#include "tunaclient.h"
CTunaClient CRCMLListens::g_TunaClient;
BOOL CRCMLListens::g_TunaInit;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CRCMLListens::CRCMLListens(LPCTSTR szFileName, HWND hwnd)
{
lstrcpyn( m_szFile, szFileName, MAX_PATH);
m_hwnd=hwnd;
m_bInitedRCML=FALSE;
m_pRootNode=NULL;
m_uiLastTip=0;
m_hwndTT=NULL;
}
CRCMLListens::~CRCMLListens()
{
UnBind(); // we need to pro-actively stop the speech recognition.
}
//
// Starts the thread
// we build the RCML node stuff, init the nodes, walk again, get the events they
// are waiting for - how do we communicate this, to use events not a callback?
// the cicero.dll can't really do that for us I don't think, as each node is independent.
// hmm.
//
void CRCMLListens::Process(void)
{
HRESULT hr;
m_pRootNode=NULL;
if( SUCCEEDED( hr=RCMLLoadFile( m_szFile, 0, &m_pRootNode )))
{
//
// what do we do now? Init the tree?
//
#ifdef _LOG_INFO
TCHAR szBuffer[1024];
wsprintf(szBuffer, TEXT(" ++++++ File %s bound to HWND 0x%08x\n"), m_szFile, hwnd );
OutputDebugString( szBuffer );
HKEY d_hK;
if( RegOpenKey( HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RCML\\SideBand"), &d_hK ) == ERROR_SUCCESS )
{
RegSetValueEx( d_hK, TEXT("Bind RCML"),NULL, REG_SZ, (LPBYTE)szBuffer, (lstrlen(szBuffer)+1)*sizeof(TCHAR) );
RegCloseKey(d_hK);
}
#endif
HWND hwnd=m_hwnd; // YUCK, forces the mapping!
m_hwnd=NULL;
MapToHwnd(hwnd);
m_pRootNode->AddRef();
WaitForSingleObject( GetEvent(), INFINITE);
m_pRootNode->Release();
}
}
//
// Stops the RCML from listening.
//
EThreadError CRCMLListens::Stop(void)
{
return BASECLASS::Stop();
}
//
// HWND is the parent window - OR NULL.
//
HRESULT CRCMLListens::MapToHwnd(HWND hwnd)
{
//
// If we were using the cache, or a new tree, do a binding.
//
if( m_pRootNode==NULL)
return E_INVALIDARG; // hmm.
if( IsWindow( hwnd ) == FALSE )
{
TRACE(TEXT("The window 0x%08x isn't valid\n"),hwnd);
return E_INVALIDARG;
}
if( m_hwnd == hwnd )
{
TRACE(TEXT("--- Already bound %s to window 0x%08x\n"), m_szFile, hwnd );
return S_OK;
}
TRACE(TEXT("--- Binding %s to window 0x%08x\n"), m_szFile, hwnd );
m_hwnd = hwnd;
HRESULT hr;
//
// This turns on or off the rules on the dialog itself (the menu).
//
IRCMLControl * pControl;
if( SUCCEEDED( m_pRootNode->QueryInterface( __uuidof( IRCMLControl), (LPVOID*)&pControl )))
{
// if( m_bInitedRCML == FALSE )
// pControl->OnInit(NULL); // so we don't screw with fonts.
pControl->put_Window(hwnd);
TRACE(TEXT("Mapping to 0x%08x \n"), hwnd );
if(hwnd!=NULL)
SetElementRuleState( pControl, L"YES", NULL );
else
SetElementRuleState( pControl, L"NO", NULL );
pControl->Release();
}
//
// Turns on all the controls on/off the page
//
IEnumUnknown * pEnum;
IRCMLNode *pTipControl=NULL;
UINT uiControlIndex=0;
if( SUCCEEDED( hr=m_pRootNode->GetChildEnum( & pEnum ))) // enumerate the children of the dialog
{
IUnknown * pUnk;
ULONG got;
while( pEnum->Next( 1, &pUnk, &got ) == S_OK )
{
if( got )
{
IRCMLControl * pControl;
if( SUCCEEDED( pUnk->QueryInterface( __uuidof( IRCMLControl ), (LPVOID*) & pControl )))
{
LPWSTR pszID;
if( SUCCEEDED( pControl->get_ID( & pszID )))
{
if( HIWORD(pszID) == 0 )
{
if( hwnd!= NULL)
{
HWND hwndCtrl = GetDlgItem( hwnd, LOWORD(pszID ) );
if( hwndCtrl )
{
// we only init the node the FIRST time it's loaded.
if( m_bInitedRCML == FALSE )
pControl->OnInit(NULL); // so we don't mess with fonts.
pControl->put_Window(hwndCtrl);
IRCMLNode * pCiceroNode=NULL;
SetElementRuleState( pControl, L"YES", &pCiceroNode );
//
// try to find uiControlIndex is the current control.
// m_uiLastTip was the last control we showed.
//
if( pCiceroNode )
{
if( uiControlIndex >= m_uiLastTip )
{
if( pTipControl == NULL )
{
if( SUCCEEDED( pCiceroNode->QueryInterface( __uuidof( IRCMLNode ),
(LPVOID*)&pTipControl ) ))
{
m_uiLastTip=uiControlIndex;
}
}
}
pCiceroNode->Release();
}
}
}
else
{
pControl->put_Window(NULL);
SetElementRuleState( pControl, L"NO", NULL );
}
}
}
pControl->Release();
}
uiControlIndex++;
}
}
m_bInitedRCML=TRUE;
pEnum->Release();
m_uiLastTip++;
if(m_uiLastTip > uiControlIndex )
m_uiLastTip=0;
}
//
// If we managed to turn the rules on/off, beep and show a tooltip
//
if( SUCCEEDED(hr) )
{
MessageBeep(MB_ICONHAND);
if(pTipControl)
{
// See if we have a CICERO node as a child with some tooltip text.
ShowTooltip( pTipControl );
pTipControl->Release();
}
}
return hr;
}
HRESULT CRCMLListens::UnBind()
{
IEnumUnknown * pEnum;
if(m_pRootNode==NULL)
return S_OK;
//
// Turn off the rules on the dialog itself (menu)
//
IRCMLControl * pControl;
if( SUCCEEDED( m_pRootNode->QueryInterface( __uuidof( IRCMLControl), (LPVOID*)&pControl )))
{
SetElementRuleState( pControl, L"NO", NULL );
pControl->Release();
}
// enumerate the children of the dialog
if( SUCCEEDED( m_pRootNode->GetChildEnum( & pEnum )))
{
IUnknown * pUnk;
ULONG got;
while( pEnum->Next( 1, &pUnk, &got ) == S_OK )
{
if( got )
{
IRCMLControl * pControl;
if( SUCCEEDED( pUnk->QueryInterface( __uuidof( IRCMLControl ), (LPVOID*) & pControl )))
{
pControl->OnDestroy( NULL, 0 ); // we don't know what info to provide.
pControl->Release();
}
}
}
pEnum->Release();
}
//
// Tell the parent dialog it's going away, in RCML this walks the unknown children
// and kills their nodes.
//
if( SUCCEEDED( m_pRootNode->QueryInterface( __uuidof( IRCMLControl), (LPVOID*)&pControl )))
{
pControl->OnDestroy( NULL, 0 ); // we don't know what info to provide.
pControl->Release();
}
m_pRootNode-> Release(); // should take down the Cicero stuff too.
return S_OK;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Called when the focus moves away from this tree, we hvae to find the Cicero nodes
// and turn them off - note the HACKY way we do this through properties!
// saved me doing a custom interface!!!!!
//
HRESULT CRCMLListens::TurnOffRules()
{
TRACE(TEXT("Trying to turn off rules on %s\n"),m_szFile);
if(m_pRootNode==NULL)
return S_OK;
IEnumUnknown * pEnum;
HRESULT hr;
//
// Turn off the rules on the dialog itself (menu)
//
IRCMLControl * pControl;
if( SUCCEEDED( m_pRootNode->QueryInterface( __uuidof( IRCMLControl), (LPVOID*)&pControl )))
{
SetElementRuleState( pControl, L"NO", NULL );
pControl->Release();
}
if( SUCCEEDED( hr=m_pRootNode->GetChildEnum( & pEnum ))) // enumerate the children of the dialog
{
IUnknown * pUnk;
ULONG got;
while( pEnum->Next( 1, &pUnk, &got ) == S_OK )
{
if( got )
{
IRCMLControl * pControl;
if( SUCCEEDED( pUnk->QueryInterface( __uuidof( IRCMLControl ), (LPVOID*) & pControl )))
{
SetElementRuleState( pControl, L"NO", NULL );
pControl->Release();
}
}
}
pEnum->Release();
}
m_hwnd=NULL; // not live.
return hr;
}
HRESULT CRCMLListens::SetElementRuleState( IRCMLControl * pControl, LPCWSTR pszState, IRCMLNode ** ppCiceroNode)
{
// We have a control, walk it's namespace children.
HRESULT hr;
IEnumUnknown * pEnumNS;
if( SUCCEEDED( hr=pControl->GetUnknownEnum( & pEnumNS ))) // walk the unknown children of this control
{
ULONG nsGot;
IUnknown * pUnkNode;
while( pEnumNS->Next( 1, &pUnkNode, &nsGot ) == S_OK )
{
if( nsGot )
{
IRCMLNode * pNode;
if( SUCCEEDED( pUnkNode->QueryInterface( __uuidof( IRCMLNode ), (LPVOID*) & pNode )))
{
WCHAR szPrefixWeNeed[]=L"CICERO:";
LPWSTR pszType;
if( SUCCEEDED(pNode->get_StringType( &pszType )))
{
lstrcpyn( szPrefixWeNeed, pszType, sizeof(szPrefixWeNeed)/sizeof(szPrefixWeNeed[0]) );
if(lstrcmpi( szPrefixWeNeed, L"CICERO:" )==0)
{
pNode->put_Attr( L"ENABLED", pszState );
if( ppCiceroNode )
{
*ppCiceroNode=pNode;
pNode->AddRef();
}
}
}
pNode->Release();
}
}
}
pEnumNS->Release();
}
return hr;
}
HRESULT CRCMLListens::ShowTooltip( IRCMLNode * pNode)
{
HRESULT hr=S_OK;
WCHAR szPrefixWeNeed[]=L"CICERO:";
LPWSTR pszType;
if( SUCCEEDED(pNode->get_StringType( &pszType )))
{
lstrcpyn( szPrefixWeNeed, pszType, sizeof(szPrefixWeNeed)/sizeof(szPrefixWeNeed[0]) );
if(lstrcmpi( szPrefixWeNeed, L"CICERO:" )==0)
{
LPWSTR pszTip;
if( SUCCEEDED( pNode->get_Attr(L"TOOLTIP", &pszTip )))
{
if( g_TunaInit==FALSE )
{
g_TunaInit=TRUE;
g_TunaClient.SetPropertyName("Command Prompts");
}
g_TunaClient.SetText(pszTip);
}
}
}
return hr;
}
void CRCMLListens::ShowBalloonTip(LPWSTR pszText)
{
}
| [
"support@cryptoalgo.cf"
] | support@cryptoalgo.cf |
aa5bde36d34fec66c5ec4144769131b6e6183573 | d5e8ed287ad0affe516498484fe478b45285919c | /Libs/Com/ServoDriverComDll/RnDriverWave.h | 2a303768df5d67651b5273b4708b7737f12eeb20 | [] | no_license | kentkdf/ServoDriveTech | ca50434ebe602996d111833901fa2549b23b85b6 | a517a06a3893a16c4825cec40551e67658500fe2 | refs/heads/master | 2021-06-26T07:55:49.863621 | 2018-01-16T05:48:22 | 2018-01-16T05:48:22 | 141,222,484 | 3 | 0 | null | 2018-07-17T02:51:26 | 2018-07-17T02:51:26 | null | GB18030 | C++ | false | false | 3,771 | h | #pragma once
//#include "gdef.h"
#include "BaseReturn_def.h"
#include "StRingNetComUser.h"
#define MAX_NUM_PRE_PACKET 512
static const int32 READ_LENTH_ONCE = 10000; //pc一次读取的double数据的个数，每一条线的数据个数,根据FPGAbuffer的大小而定义
class CRnDriverWave
{
public:
CRnDriverWave();
~CRnDriverWave();
static const int32 RAW_BUFFER_LENTH = 200000; //PC读取FPGA缓存的buffer，没有分离曲线
static const int32 WAVE_LINE_BUFFER_LENTH = 200000; //曲线buffuer
static const int32 RAW_CACHE_BUFFER_LENTH = 10000; //raw data buffer lenth
static const int32 FRAME_KEYWORD_DISTANCE_NUM = 256;//Dsp负责每256帧数据增加一个同步帧
static const int32 FRAME_KEYWORD_LOW = 0xaaaa; //同步帧的定义
static const int32 FRAME_KEYWORD_HIGH = 0x5555;
static const Uint32 FRAME_KEYWORD = 0x5555aaaa;//
static const Uint32 MAX_FRAME_NUM = 33*1000;//
// static const int16 pw_MaxAxis = MAX_DSP_WAVE * 2; //最大轴数定义
Uint16 m_dsp_id;//which combine with des_id and des_ch; m_dsp_id = (des_id <<8) | (des_ch)
protected:
void* m_critical_section; //CRITICAL_SECTION for data receive
// WAVE_BUF_PRM m_wave_param;
Uint16 m_size_of_frame;
Uint16 m_wave_en;
Uint16 m_wave_num;
Uint16 *m_wave_byte_size_list;
BOOL m_find_keyword;
Uint16 m_keyword_distane_cnt;
//////////////////////////////////////////////////////////////////////////
Uint8 *m_pDataTmpBuffer; //the data from the dsp will fill to here
// Uint8 m_pDataTmpBuffer[2 * MAX_NUM_PRE_PACKET];
// Uint16 m_pDataTmp_size;
Uint16 m_pDataTmp_valid_num;//
//////////////////////////////////////////////////////////////////////////
Uint8 *m_pFrameBuffer; //m_pFrameBuffer[m_frame_max_num*m_frame_byte_size];
// Uint8 m_pFrameBuffer[6*MAX_FRAME_NUM];
// Uint16 m_frame_max_num; //this var is used to malloc the memeroy;
Uint32 m_frame_valid_num; //this var is used to calc how many frames valid;
Uint32 m_frame_index;
//////////////////////////////////////////////////////////////////////////
double *m_pDataUserRead; //用于存放上层读取的数据
// double m_pDataUserRead[2 * READ_LENTH_ONCE]; //用于存放上层读取的数据
//////////////////////////////////////////////////////////////////////////
Uint32 m_frame_write_cnt; //total write frame num from start plot.
Uint32 m_frame_read_cnt; //total read frame num from start plot.
Uint32 m_data_lose_cnt;// this will not clear
Uint32 m_read_lose_cnt;// this will clear when the cfg update;
Uint32 m_data_ok_cnt;
Uint32 m_read_ok_cnt;// this will clear when the cfg update;
protected:
short SearchFrameKeyWord(Uint16& key_index, Uint16 byte_num, Uint8* pData);
short FetchWaveDataToFrameBuffer(Uint16 byte_num, Uint8* pData, Uint16& left_byte_num);
// short ClearDspWaveVar();
public:
// short ParseDspWaveData(Uint16 dsp_id, Uint16 byte_num, Uint8* pData);
// double plotDataBuffer_dsp[MAX_DSP_WAVE][MAX_WAVE_PLOT_NUM][READ_LENTH_ONCE];//用于存放上层读取的数据
// short InitDspWaveVar(WAVE_BUF_PRM& wave);
// short CloseDspWave(WAVE_BUF_PRM& wave);
short InitDspWaveVar(Uint16 wave_num, Uint16 *wave_byte_size_list);
short CloseDspWave();
short PW_PcGetDspWaveData(double** data, Uint32& number);
short ParseDspWaveData(Uint16 dsp_id, Uint16 byte_num, Uint8* pData);
#ifdef TIME_TEST
int16 readnumber_testA[10000];
int16 readnumber_test_indexA;
int16 readnumber_testB[1000];
int16 readnumber_test_indexB;
int32 readpointerA[1000];
int32 writepointerA[1000];
int16 pointerindexA;
int16 readpointerB[1000];
int16 writepointerB[1000];
int16 pointerindexB;
int32 value_exceed;
int32 overflow_flag;
int16 allnumber_test[10000];
int32 allnumber_test_index;
#endif
};
| [
"chenchao_szu@163.comm"
] | chenchao_szu@163.comm |
5136aeb1967fbb3c32dcf5ca071e5ff82bfcf959 | 051a2d1901b27a841c9d11b31c4bd1512629ae0c | /deps/gfakluge/src/tinyFA/tinyFA.hpp | 83b6414b5664a9a893175242f043c71cc24d6594 | [
"MIT"
] | permissive | ibharvey/seqan3_cmake_error | b78f813e4b8e864e0c4753234ea68e8ccf454e6a | a81a65a72bd7658621e7c14d46e03b50b0b2f38d | refs/heads/master | 2022-04-12T09:28:31.006973 | 2020-03-02T18:56:06 | 2020-03-02T18:56:06 | 238,558,965 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,621 | hpp | #ifndef TINY_FA_HPP
#define TINY_FA_HPP
#include <sys/types.h>
#include <cstdio>
#pragma once
#define _FILE_OFFSET_BITS 64
#ifdef WIN32
#define ftell64(a) _ftelli64(a)
#define fseek64(a,b,c) _fseeki64(a,b,c)
typedef __int64 off_type;
#elif defined(__APPLE__) || defined(__FreeBSD__)
#define ftell64(a) ftello(a)
#define fseek64(a,b,c) fseeko(a,b,c)
typedef off_t off_type;
#else
#define ftell64(a) ftello(a)
#define fseek64(a,b,c) fseeko(a,b,c)
typedef __off64_t off_type;
#endif
#include <string>
#include <sstream>
#include <ostream>
#include <vector>
#include <fstream>
#include <unordered_map>
#include <map>
#include <cstdint>
#include <assert.h>
#include <algorithm>
#include <sys/stat.h>
#include "pliib.hpp"
namespace TFA{
// From https://stackoverflow.com/questions/4157687/using-char-as-a-key-in-stdmap
struct custom_char_comparator
{
bool operator()(char const *a, char const *b) const
{
return std::strcmp(a, b) < 0;
}
};
struct tiny_faidx_entry_t {
char* name = NULL;
int name_len = 0;
std::int32_t line_char_len = -1;
std::int32_t line_byte_len = 0;
std::int64_t seq_len = 0;
std::int64_t raw_len = 0;
std::int64_t offset = -1;
tiny_faidx_entry_t(){
name = NULL;
name_len = 0;
line_char_len = -1;
line_byte_len = 0;
seq_len = 0;
raw_len = 0;
offset = -1;
};
tiny_faidx_entry_t(std::vector<std::string> splits){
assert(splits.size() == 5);
this->name_len = splits[0].length();
this->name = new char[this->name_len + 1];
memcpy(this->name, splits[0].c_str(), splits[0].length() * sizeof(char));
this->name[this->name_len] = '\0';
this->seq_len = std::stoll(splits[1]);
this->offset = std::stoull(splits[2]);
this->line_char_len = std::stoi(splits[3]);
this->line_byte_len = std::stoi(splits[4]);
};
// Five columns
// seqname seqlen offset line_char_len line_byte_len
std::string to_string(){
std::stringstream st;
st << name << '\t' << seq_len << '\t' << offset << '\t' << line_char_len << '\t' << line_byte_len << std::endl;
return st.str();
};
void write_to_stream(std::ostream& os){
os << name << '\t' << seq_len << '\t' << offset << '\t' << line_char_len << '\t' << line_byte_len << std::endl;
};
};
struct custom_faidx_entry_t_comparator
{
bool operator()(tiny_faidx_entry_t const *a, tiny_faidx_entry_t const *b) const
{
return a->offset < b->offset;
}
};
struct tiny_faidx_t{
std::map<char*, tiny_faidx_entry_t*, custom_char_comparator> seq_to_entry;
FILE* fasta = NULL;
void close(){
if (fasta != NULL){
fclose(fasta);
}
for (auto k : seq_to_entry){
delete [] k.second->name;
delete k.second;
}
};
void add(tiny_faidx_entry_t*& entry){
seq_to_entry[entry->name] = entry;
};
~tiny_faidx_t(){
close();
};
bool hasSeqID(const char* s) const {
return (seq_to_entry.count( (char*) s) != 0);
};
void get(const char* seqname, tiny_faidx_entry_t*& entry) const {
entry = seq_to_entry.at((char*) seqname);
};
void write(std::ostream& os) const {
std::vector<tiny_faidx_entry_t*> sorted_entries;
for (auto x : seq_to_entry){
sorted_entries.push_back(x.second);
}
std::sort(sorted_entries.begin(), sorted_entries.end(), custom_faidx_entry_t_comparator());
for (auto x : sorted_entries){
x->write_to_stream(os);
}
};
void write(const char* filename) const{
std::ofstream ofi;
ofi.open(filename);
if (ofi.good()){
write(ofi);
}
};
} ;
inline void createFAIndex(const char* fastaName, tiny_faidx_t& fai){
uint64_t line_number = 0;
int32_t line_length = 0;
uint64_t offset = 0;
std::string line;
std::ifstream faFile;
faFile.open(fastaName);
if (!(fai.fasta = fopen(fastaName, "r"))){
std::cerr << "Error: couldn't open fasta file " << fastaName << std::endl;
exit(1);
}
tiny_faidx_entry_t* entry = new tiny_faidx_entry_t();
if (faFile.is_open()){
while(std::getline(faFile, line)){
++line_number;
line_length = line.length();
if (line[0] == '>' || line[0] == '@'){
// This is a valid fasta name line
// Start a new entry and begin filling it.
if (entry->name_len != 0){
fai.add(entry);
entry = new tiny_faidx_entry_t();
}
line = line.substr(1, line_length);
char* name = new char[line_length];
std::strcpy(name, line.c_str());
pliib::strip(name, line_length - 1, ' ');
pliib::trim_after_char(name, strlen(name), ' ');
//std::cerr << name << std::endl;
entry->name_len = std::strlen(name);
entry->name = new char[entry->name_len + 1];
std::strcpy(entry->name, name);
entry->name[entry->name_len] = '\0';
}
else if (line[0] == '+'){
std::getline(faFile, line);
line_length = line.length();
offset += line_length + 1;
std::getline(faFile, line);
line_length = line.length();
offset += line_length + 1;
}
else{
if (entry->offset == -1){
entry->line_char_len = line_length;
entry->line_byte_len = line_length + 1;
entry->offset = offset;
}
entry->seq_len += line_length;
entry->raw_len += line_length + 1;
}
offset += line_length + 1;
}
if (entry->seq_len >= 0){
fai.add(entry);
}
}
faFile.close();
};
inline void writeFAIndex(const char* fastaName, const tiny_faidx_t& fai){
// Create index outfile with the correct name
std::string fn(fastaName);
fn = fn + ".fai";
std::ofstream ofi(fn.c_str());
if (ofi.good()){
fai.write(ofi);
}
};
inline bool checkFAIndexFileExists(const char* fastaName){
struct stat statFileInfo;
std::string indexFileName(fastaName);
indexFileName = indexFileName + ".fai";
return stat(indexFileName.c_str(), &statFileInfo) == 0;
};
inline char* indexFileName(const char* fastaName){
int len = strlen(fastaName);
static const char* file_ext = ".fai";
char* ret = new char[len + 5];
ret[len + 4] = '\0';
strcpy(ret, fastaName);
strcpy(ret + len, file_ext);
return ret;
};
inline void parseFAIndex(const char* fastaFileName, tiny_faidx_t& fai){
std::ifstream ifi;
char* ifn = indexFileName(fastaFileName);
ifi.open((const char*) ifn);
if (!(fai.fasta = fopen(fastaFileName, "r"))){
std::cerr << "Error: couldn't open fasta file " << fastaFileName << std::endl;
exit(1);
}
if (ifi.is_open()){
std::string line;
while(std::getline(ifi, line)){
std::vector<std::string> splits = pliib::split(line.c_str(), '\t');
tiny_faidx_entry_t* t = new tiny_faidx_entry_t(splits);
fai.add(t);
}
}
else{
std::cerr << "Couldn't open index " << ifn << "." << std::endl;
}
ifi.close();
delete [] ifn;
};
inline void getSequenceLength(const tiny_faidx_t& fai, const char* seqname, uint32_t& length){
tiny_faidx_entry_t* entry;
if (fai.hasSeqID(seqname)){
fai.get(seqname, entry);
length = entry->seq_len;
}
};
inline bool hasSequence(const tiny_faidx_t& fai, const char* seqname){
return fai.hasSeqID(seqname);
};
inline void getSequence( const tiny_faidx_t& fai, const char* seqname, char*& seq){
uint32_t sz = 0;
tiny_faidx_entry_t* entry;
if (fai.fasta == NULL){
std::cerr << "FASTA file not set for index." << std::endl;
exit(9);
}
if (fai.hasSeqID(seqname)){
fai.get(seqname, entry);
int num_line_breaks = entry->seq_len / entry->line_char_len;
sz = entry->seq_len + num_line_breaks;
seq = new char[sz + 1];
fseek64(fai.fasta, entry->offset, SEEK_SET);
if (fread(seq, sizeof(char), sz, fai.fasta)){
#ifdef DEBUG
std::cerr << entry->seq_len << " " <<
entry->line_byte_len << " " <<
num_line_breaks << std::endl;
#endif
seq[sz] = '\0';
pliib::remove_nulls_and_whitespace(seq, sz);
#ifdef DEBUG
std::cerr << strlen(seq) << std::endl;
#endif
}
}
else{
std::cerr << "No sequence found for ID: " << seqname << "." << std::endl;
}
};
inline void getSequence( const tiny_faidx_t& fai, const char* seqname,
char*& seq, int start, int end){
if (fai.fasta == NULL){
std::cerr << "FASTA file not set for index." << std::endl;
exit(9);
}
getSequence(fai, seqname, seq);
end = std::min(end, (int) strlen(seq));
start = std::max(0, (int) start);
char* ret = new char[end - start + 1];
ret[end - start] = '\0';
memcpy(ret, seq + start, (end - start) * sizeof(char) );
delete seq;
seq = ret;
};
}
#endif
| [
"burstolava@yahoo.com"
] | burstolava@yahoo.com |
475e233ae699d395eaabc7ec383bc4930375911e | 2407b7834ac70df0b14dda6782e9ce048a2d1279 | /Practice/FC/Ceshi.cpp | 18e1624b07d267b0ab4b8ffc5973a846d8194551 | [] | no_license | sssSSSay/Code | 44ad26b521674a1ecd5a78af1da448df97305ecf | 8f853943103b549a9c8795493530793ccbf1b7a2 | refs/heads/master | 2021-01-12T00:59:05.285035 | 2017-08-10T13:30:09 | 2017-08-10T13:30:09 | 78,328,140 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 290 | cpp | #include<iostream>
#include<windows.h>
using namespace std;
int main() {
while(1) {
system("data > test.in");
system("1245Force < test.in > ans.out");
system("[CODEVS]1245 < test.in > my.out");
if(system("fc my.out ans.out")) break;
}
return 0;
}
| [
"1094238312@QQ.com"
] | 1094238312@QQ.com |
13c5f750ad959e6eff1aecf95856b8e741eca15a | 1cf86f3b8a75e4b9e2256a49dd7f904d1bc3667c | /src/meta/ui.conv.h | 42d4c517f703f67347e66f26656fccef5b25636d | [
"Zlib"
] | permissive | hugoam/two | bfaa6f0184e7e45e4f2fbc0e2d6257ed51dfe54d | d4b386f48c572da03ac5c89e702cf08f388d434d | refs/heads/master | 2023-04-27T11:10:21.640620 | 2023-04-18T21:04:38 | 2023-04-18T21:04:38 | 116,430,022 | 717 | 63 | Zlib | 2019-05-11T16:04:24 | 2018-01-05T21:48:50 | C++ | UTF-8 | C++ | false | false | 3,916 | h | #pragma once
#ifndef TWO_MODULES
#include <ui/Types.h>
#endif
#if !defined TWO_MODULES || defined TWO_TYPE_LIB
#include <refl/Meta.h>
#include <refl/Enum.h>
#include <infra/StringOps.h>
#endif
namespace two
{
export_ template <> inline void to_value(const string& str, two::FlowAxis& val) { val = two::FlowAxis(enu<two::FlowAxis>().value(str.c_str())); };
export_ template <> inline void to_string(const two::FlowAxis& val, string& str) { str = enu<two::FlowAxis>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::Pivot& val) { val = two::Pivot(enu<two::Pivot>().value(str.c_str())); };
export_ template <> inline void to_string(const two::Pivot& val, string& str) { str = enu<two::Pivot>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::Align& val) { val = two::Align(enu<two::Align>().value(str.c_str())); };
export_ template <> inline void to_string(const two::Align& val, string& str) { str = enu<two::Align>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::Solver& val) { val = two::Solver(enu<two::Solver>().value(str.c_str())); };
export_ template <> inline void to_string(const two::Solver& val, string& str) { str = enu<two::Solver>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::AutoLayout& val) { val = two::AutoLayout(enu<two::AutoLayout>().value(str.c_str())); };
export_ template <> inline void to_string(const two::AutoLayout& val, string& str) { str = enu<two::AutoLayout>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::LayoutFlow& val) { val = two::LayoutFlow(enu<two::LayoutFlow>().value(str.c_str())); };
export_ template <> inline void to_string(const two::LayoutFlow& val, string& str) { str = enu<two::LayoutFlow>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::Sizing& val) { val = two::Sizing(enu<two::Sizing>().value(str.c_str())); };
export_ template <> inline void to_string(const two::Sizing& val, string& str) { str = enu<two::Sizing>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::Preset& val) { val = two::Preset(enu<two::Preset>().value(str.c_str())); };
export_ template <> inline void to_string(const two::Preset& val, string& str) { str = enu<two::Preset>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::Clip& val) { val = two::Clip(enu<two::Clip>().value(str.c_str())); };
export_ template <> inline void to_string(const two::Clip& val, string& str) { str = enu<two::Clip>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::Opacity& val) { val = two::Opacity(enu<two::Opacity>().value(str.c_str())); };
export_ template <> inline void to_string(const two::Opacity& val, string& str) { str = enu<two::Opacity>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::WidgetState& val) { val = two::WidgetState(enu<two::WidgetState>().value(str.c_str())); };
export_ template <> inline void to_string(const two::WidgetState& val, string& str) { str = enu<two::WidgetState>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::ui::PopupFlags& val) { val = two::ui::PopupFlags(enu<two::ui::PopupFlags>().value(str.c_str())); };
export_ template <> inline void to_string(const two::ui::PopupFlags& val, string& str) { str = enu<two::ui::PopupFlags>().name(uint32_t(val)); };
export_ template <> inline void to_value(const string& str, two::WindowState& val) { val = two::WindowState(enu<two::WindowState>().value(str.c_str())); };
export_ template <> inline void to_string(const two::WindowState& val, string& str) { str = enu<two::WindowState>().name(uint32_t(val)); };
}
| [
"hugo.amiard@wonderlandengine.com"
] | hugo.amiard@wonderlandengine.com |
22afb8e74302f29cd5ee00eeefb3686308cee2ab | a240f831c7e1795ee005493612af0ba6bf2bb849 | /ABC/ABC127/B.cpp | 17ad99b11c1318125a35446e2fcaf6bc6a8d9faf | [] | no_license | sensen963/AtCoder | db84fdf46c2d3526aa9e2d7d5c49ebba8b854714 | c0cd9e750408aa100836466c8bb1a1e33ae57c67 | refs/heads/master | 2021-03-27T10:11:46.039139 | 2020-11-29T04:59:51 | 2020-11-29T04:59:51 | 109,882,192 | 0 | 0 | null | 2020-07-26T13:21:52 | 2017-11-07T19:38:58 | C++ | UTF-8 | C++ | false | false | 655 | cpp | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <numeric>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define REP(i, n) for(int i = 0; i < (int)(n); i++)
int auau(int r, int D, int x){
return (r * x - D);
}
int main() {
int r, D, x;
cin >> r >> D >> x;
int tmp = x;
REP(i, 10){
tmp = auau(r, D, tmp);
cout << tmp << endl;
}
return 0;
}
| [
"nanablue2035@gmail.com"
] | nanablue2035@gmail.com |
43627a8a237f1a8029a938f22625fb9374b918a3 | 641fa8341d8c436ad24945bcbf8e7d7d1dd7dbb2 | /components/cryptauth/fake_secure_message_delegate_unittest.cc | ba46991b716ff2dc8735ed1389f50ed17c7e5103 | [
"BSD-3-Clause"
] | permissive | massnetwork/mass-browser | 7de0dfc541cbac00ffa7308541394bac1e945b76 | 67526da9358734698c067b7775be491423884339 | refs/heads/master | 2022-12-07T09:01:31.027715 | 2017-01-19T14:29:18 | 2017-01-19T14:29:18 | 73,799,690 | 4 | 4 | BSD-3-Clause | 2022-11-26T11:53:23 | 2016-11-15T09:49:29 | null | UTF-8 | C++ | false | false | 7,893 | cc | // Copyright 2014 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 "components/cryptauth/fake_secure_message_delegate.h"
#include "base/bind.h"
#include "base/macros.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace cryptauth {
namespace {
const char kTestPublicKey[] = "the private key is in another castle";
const char kPayload[] = "500 tons of uranium";
const char kSymmetricKey[] = "hunter2";
const char kPublicMetadata[] = "brought to you by our sponsors";
const char kAssociatedData[] = "save 20% bytes on your nonce insurance";
const char kVerificationKeyId[] = "the one with the red stripes";
const char kDecryptionKeyId[] = "it's in your pocket somewhere";
// Callback for saving the result of GenerateKeys().
void SaveKeyPair(std::string* private_key_out,
std::string* public_key_out,
const std::string& private_key,
const std::string& public_key) {
*private_key_out = private_key;
*public_key_out = public_key;
}
// Callback for saving the result of DeriveKey() and CreateSecureMessage().
void SaveString(std::string* out, const std::string& value) {
*out = value;
}
// Callback for saving the result of UnwrapSecureMessage().
void SaveUnwrapResults(std::string* payload_out,
securemessage::Header* header_out,
bool verified,
const std::string& payload,
const securemessage::Header& header) {
ASSERT_TRUE(verified);
*payload_out = payload;
*header_out = header;
}
// Returns the CreateOptions struct to create the test message.
SecureMessageDelegate::CreateOptions GetCreateOptions(
securemessage::EncScheme encryption_scheme,
securemessage::SigScheme signature_scheme) {
SecureMessageDelegate::CreateOptions create_options;
create_options.encryption_scheme = encryption_scheme;
create_options.signature_scheme = signature_scheme;
create_options.public_metadata = kPublicMetadata;
create_options.associated_data = kAssociatedData;
create_options.verification_key_id = kVerificationKeyId;
create_options.decryption_key_id = kDecryptionKeyId;
return create_options;
}
// Returns the UnwrapOptions struct to unwrap the test message.
SecureMessageDelegate::UnwrapOptions GetUnwrapOptions(
securemessage::EncScheme encryption_scheme,
securemessage::SigScheme signature_scheme) {
SecureMessageDelegate::UnwrapOptions unwrap_options;
unwrap_options.encryption_scheme = encryption_scheme;
unwrap_options.signature_scheme = signature_scheme;
unwrap_options.associated_data = kAssociatedData;
return unwrap_options;
}
void CheckSerializedSecureMessage(
const std::string& serialized_message,
const SecureMessageDelegate::CreateOptions& create_options) {
securemessage::SecureMessage secure_message;
ASSERT_TRUE(secure_message.ParseFromString(serialized_message));
securemessage::HeaderAndBody header_and_body;
ASSERT_TRUE(
header_and_body.ParseFromString(secure_message.header_and_body()));
const securemessage::Header& header = header_and_body.header();
EXPECT_EQ(create_options.signature_scheme, header.signature_scheme());
EXPECT_EQ(create_options.encryption_scheme, header.encryption_scheme());
EXPECT_EQ(create_options.verification_key_id, header.verification_key_id());
EXPECT_EQ(create_options.decryption_key_id, header.decryption_key_id());
EXPECT_EQ(create_options.public_metadata, header.public_metadata());
}
} // namespace
class CryptAuthFakeSecureMessageDelegateTest : public testing::Test {
protected:
CryptAuthFakeSecureMessageDelegateTest() {}
FakeSecureMessageDelegate delegate_;
DISALLOW_COPY_AND_ASSIGN(CryptAuthFakeSecureMessageDelegateTest);
};
TEST_F(CryptAuthFakeSecureMessageDelegateTest, GenerateKeyPair) {
std::string public_key1, private_key1;
delegate_.GenerateKeyPair(
base::Bind(&SaveKeyPair, &public_key1, &private_key1));
EXPECT_NE(private_key1, public_key1);
std::string public_key2, private_key2;
delegate_.GenerateKeyPair(
base::Bind(&SaveKeyPair, &public_key2, &private_key2));
EXPECT_NE(private_key2, public_key2);
EXPECT_NE(public_key1, public_key2);
EXPECT_NE(private_key1, private_key2);
delegate_.set_next_public_key(kTestPublicKey);
std::string public_key3, private_key3;
delegate_.GenerateKeyPair(
base::Bind(&SaveKeyPair, &public_key3, &private_key3));
EXPECT_EQ(kTestPublicKey, public_key3);
EXPECT_NE(private_key3, public_key3);
EXPECT_NE(public_key1, public_key3);
EXPECT_NE(private_key1, private_key3);
}
TEST_F(CryptAuthFakeSecureMessageDelegateTest, DeriveKey) {
delegate_.set_next_public_key("key_pair_1");
std::string public_key1, private_key1;
delegate_.GenerateKeyPair(
base::Bind(&SaveKeyPair, &public_key1, &private_key1));
delegate_.set_next_public_key("key_pair_2");
std::string public_key2, private_key2;
delegate_.GenerateKeyPair(
base::Bind(&SaveKeyPair, &public_key2, &private_key2));
std::string symmetric_key1, symmetric_key2;
delegate_.DeriveKey(private_key1, public_key2,
base::Bind(&SaveString, &symmetric_key1));
delegate_.DeriveKey(private_key2, public_key1,
base::Bind(&SaveString, &symmetric_key2));
EXPECT_EQ(symmetric_key1, symmetric_key2);
}
TEST_F(CryptAuthFakeSecureMessageDelegateTest,
CreateAndUnwrapWithSymmetricKey) {
// Create SecureMessage using symmetric key.
SecureMessageDelegate::CreateOptions create_options =
GetCreateOptions(securemessage::AES_256_CBC, securemessage::HMAC_SHA256);
std::string serialized_message;
delegate_.CreateSecureMessage(kPayload, kSymmetricKey, create_options,
base::Bind(&SaveString, &serialized_message));
CheckSerializedSecureMessage(serialized_message, create_options);
// Unwrap SecureMessage using symmetric key.
SecureMessageDelegate::UnwrapOptions unwrap_options =
GetUnwrapOptions(securemessage::AES_256_CBC, securemessage::HMAC_SHA256);
std::string payload;
securemessage::Header header;
delegate_.UnwrapSecureMessage(
serialized_message, kSymmetricKey, unwrap_options,
base::Bind(&SaveUnwrapResults, &payload, &header));
EXPECT_EQ(kPayload, payload);
}
TEST_F(CryptAuthFakeSecureMessageDelegateTest,
CreateAndUnwrapWithAsymmetricKey) {
delegate_.set_next_public_key(kTestPublicKey);
std::string public_key, private_key;
delegate_.GenerateKeyPair(
base::Bind(&SaveKeyPair, &public_key, &private_key));
// Create SecureMessage using asymmetric key.
SecureMessageDelegate::CreateOptions create_options =
GetCreateOptions(securemessage::NONE, securemessage::ECDSA_P256_SHA256);
std::string serialized_message;
delegate_.CreateSecureMessage(kPayload, private_key, create_options,
base::Bind(&SaveString, &serialized_message));
CheckSerializedSecureMessage(serialized_message, create_options);
// Unwrap SecureMessage using symmetric key.
SecureMessageDelegate::UnwrapOptions unwrap_options =
GetUnwrapOptions(securemessage::NONE, securemessage::ECDSA_P256_SHA256);
std::string payload;
securemessage::Header header;
delegate_.UnwrapSecureMessage(
serialized_message, public_key, unwrap_options,
base::Bind(&SaveUnwrapResults, &payload, &header));
EXPECT_EQ(kPayload, payload);
}
TEST_F(CryptAuthFakeSecureMessageDelegateTest, GetPrivateKeyForPublicKey) {
delegate_.set_next_public_key(kTestPublicKey);
std::string public_key, private_key;
delegate_.GenerateKeyPair(
base::Bind(&SaveKeyPair, &public_key, &private_key));
EXPECT_EQ(kTestPublicKey, public_key);
EXPECT_EQ(private_key, delegate_.GetPrivateKeyForPublicKey(kTestPublicKey));
}
} // proximity_auth
| [
"xElvis89x@gmail.com"
] | xElvis89x@gmail.com |
b73c3559311457436b73045f729af664738e8c76 | 2acb779af600f1137080b9b7fc8db9c525bf51f6 | /struct/drvhinge.h | 2d97df234086c02e3f9609340c271625957ce0c1 | [] | no_license | akshayrk95/MBdyn | 93b0d0af0f03ea0fd148a53d2cdde8b2037cc957 | 039cb68b9002f7451786a7c2f3a359dfd89609f0 | refs/heads/master | 2016-09-06T16:05:32.019951 | 2015-03-04T20:29:44 | 2015-03-04T20:29:44 | 31,678,254 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,084 | h | /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/struct/drvhinge.h,v 1.31 2014/07/22 19:19:23 masarati Exp $ */
/*
* MBDyn (C) is a multibody analysis code.
* http://www.mbdyn.org
*
* Copyright (C) 1996-2014
*
* Pierangelo Masarati <masarati@aero.polimi.it>
* Paolo Mantegazza <mantegazza@aero.polimi.it>
*
* Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano
* via La Masa, 34 - 20156 Milano, Italy
* http://www.aero.polimi.it
*
* Changing this copyright notice is forbidden.
*
* 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 (version 2 of the License).
*
*
* 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
*/
/* Deformable hinges */
#ifndef DRVHINGE_H
#define DRVHINGE_H
#include "joint.h"
#include "constltp.h"
/* DriveHingeJoint - begin */
class DriveHingeJoint :
virtual public Elem, public Joint, public TplDriveOwner<Vec3> {
private:
protected:
const StructNode* pNode1;
const StructNode* pNode2;
const Mat3x3 R1h;
const Mat3x3 R2h;
Mat3x3 R1Ref;
Mat3x3 RRef;
Vec3 ThetaRef;
Vec3 ThetaCurr;
Vec3 M;
bool bFirstRes;
void AssMat(FullSubMatrixHandler& WM, doublereal dCoef);
void AssVec(SubVectorHandler& WorkVec, doublereal dCoef);
public:
/* Costruttore non banale */
DriveHingeJoint(unsigned int uL,
const DofOwner* pDO,
const TplDriveCaller<Vec3>* pDC,
const StructNode* pN1,
const StructNode* pN2,
const Mat3x3& R1,
const Mat3x3& R2,
flag fOut);
/* Distruttore */
virtual ~DriveHingeJoint(void);
/* Tipo di joint */
virtual Joint::Type GetJointType(void) const {
return DRIVEHINGE;
};
/* Contributo al file di restart */
virtual std::ostream& Restart(std::ostream& out) const;
virtual void Output(OutputHandler& OH) const;
void SetValue(DataManager *pDM,
VectorHandler& X, VectorHandler& XP,
SimulationEntity::Hints *ph = 0);
virtual Hint *
ParseHint(DataManager *pDM, const char *s) const;
virtual unsigned int iGetNumDof(void) const {
return 3;
};
virtual std::ostream&
DescribeDof(std::ostream& out,
const char *prefix = "",
bool bInitial = false) const;
virtual void
DescribeDof(std::vector<std::string>& desc,
bool bInitial = false,
int i = -1) const;
virtual std::ostream&
DescribeEq(std::ostream& out,
const char *prefix = "",
bool bInitial = false) const;
virtual void
DescribeEq(std::vector<std::string>& desc,
bool bInitial = false,
int i = -1) const;
virtual DofOrder::Order GetDofType(unsigned int i) const {
ASSERT(i >= 0 && i <= 3);
return DofOrder::ALGEBRAIC;
};
virtual void WorkSpaceDim(integer* piNumRows,
integer* piNumCols) const {
*piNumRows = 9;
*piNumCols = 9;
};
/* assemblaggio jacobiano */
virtual VariableSubMatrixHandler&
AssJac(VariableSubMatrixHandler& WorkMat,
doublereal dCoef,
const VectorHandler& XCurr,
const VectorHandler& XPrimeCurr);
/* assemblaggio residuo */
virtual SubVectorHandler&
AssRes(SubVectorHandler& WorkVec,
doublereal dCoef,
const VectorHandler& XCurr,
const VectorHandler& XPrimeCurr);
/* Aggiorna le deformazioni ecc. */
virtual void AfterPredict(VectorHandler& X, VectorHandler& XP);
/* funzioni usate nell'assemblaggio iniziale */
virtual unsigned int iGetInitialNumDof(void) const {
return 6;
};
virtual void InitialWorkSpaceDim(integer* piNumRows,
integer* piNumCols) const {
*piNumRows = 18;
*piNumCols = 18;
};
/* Contributo allo jacobiano durante l'assemblaggio iniziale */
virtual VariableSubMatrixHandler&
InitialAssJac(VariableSubMatrixHandler& WorkMat,
const VectorHandler& XCurr);
/* Contributo al residuo durante l'assemblaggio iniziale */
virtual SubVectorHandler&
InitialAssRes(SubVectorHandler& WorkVec,
const VectorHandler& XCurr);
/* Dati privati (aggiungere magari le reazioni vincolari) */
virtual unsigned int iGetNumPrivData(void) const;
unsigned int iGetPrivDataIdx(const char *s) const;
virtual doublereal dGetPrivData(unsigned int i = 0) const;
/* *******PER IL SOLUTORE PARALLELO******** */
/* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
utile per l'assemblaggio della matrice di connessione fra i dofs */
virtual void GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
connectedNodes.resize(2);
connectedNodes[0] = pNode1;
connectedNodes[1] = pNode2;
};
/* ************************************************ */
};
/* DriveHingeJoint - end */
#endif /* DRVHINGE_H */
| [
"akshayrk@live.in"
] | akshayrk@live.in |
8377a6ad073869e756caef93f156f0b3095fc2e9 | 277698e0fa6c846f1209adbd840afab8aea6d7b5 | /code/ViewHint.h | d0495b84da979484c9165d498cd5ff76593107fc | [
"MIT"
] | permissive | omerdagan84/neomem | ad67dba738efced735f614029d7c237f574ecbbe | 7d2f782bb37f1ab0ac6580d00672e114605afab7 | refs/heads/master | 2021-01-20T19:45:32.004246 | 2014-04-12T13:09:20 | 2014-04-12T13:09:20 | 22,289,594 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 440 | h | // ViewHint.h: interface for the CViewHint class.
#if !defined(AFX_VIEWHINT_H__BEF95D3B_DEB0_11D3_9183_C02653C10000__INCLUDED_)
#define AFX_VIEWHINT_H__BEF95D3B_DEB0_11D3_9183_C02653C10000__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CViewHint : public CObject
{
public:
CViewHint();
virtual ~CViewHint();
};
#endif // !defined(AFX_VIEWHINT_H__BEF95D3B_DEB0_11D3_9183_C02653C10000__INCLUDED_)
| [
"bburns@3bad96a7-2d8f-4f48-a7ae-748201937164"
] | bburns@3bad96a7-2d8f-4f48-a7ae-748201937164 |
e40d0b3c5b311d3daa77e28cc320ff1bf515e507 | d5e6d48fb5f9fa73ef0c2593bb2d2dbeb67dd95e | /Banking.cpp | 9d5210115aa2b8faab8608e2b54e4b62154dd7f6 | [] | no_license | shivangalld/OS_Lab | 91517186651c4ec8087eeae537227807e54bd6c8 | 752990280d68ec513f2776f4190a58aabb753021 | refs/heads/master | 2021-06-06T02:13:22.504547 | 2016-09-26T19:09:06 | 2016-09-26T19:09:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,870 | cpp | #include<iostream.h>
#include<stdio.h>
#include<conio.h>
class bank
{
private:
int ac_no,account;
float balance;
char name[20];
public:
void open(void);
void deposite(int);
void withdraw(int);
void search(int);
void display(void);
};
void bank::open(void)
{
cout<<"ENTER YOUR NAME : ";
cin>>name;
cout<<"ENTER YOUR ACCOUNT NUMBER : ";
cin>>account;
cout<<"ENTER THE AMOUNT OF MONEY : BDT ";
cin>>balance;
}
void bank::deposite(int j)
{
int bnc;
if(account==j)
{
cout<<"ENTER THE AMOUNT OF MONEY : BDT ";
cin>>bnc;
balance=balance+bnc;
cout<<"\n\n\tJOB HAS DONE WELL !!! \n";
}
}
void bank::withdraw(int k)
{
int blnc,p;
if(account==k)
{
cout<<"YOUR CURRENT ACCOUNT BALANCE IS BDT "<<balance<<"\n"<<"THE AMOUNT OF MONEY YOU WANT TO WITHDRAW IS BDT ";
cin>>blnc;
p=balance-blnc;
{ if(p<0)
cout<<"SORRY !!! THERE IS NOT ENOUGH MONEY IN YOUR ACCOUNT\n";
else if(p>=0)
{
cout<<"\n\tYOUR REQUEST TO WITHDRAW MONEY HAS DONE\n\n";
balance=p;
}
}
}
}
void bank::display(void)
{ cout<<"\n\nNAME : "<<name<<"\n\nACCOUNT NO. "<<account<<"\n\nBALANCE : BDT "<<balance<<"\n\n";
}
void bank::search(int m)
{
if(account==m)
{
cout<<"\n\n*******Account Holder's INFO*******";
cout<<"\n\nNAME : "<<name<<"\n\nACCOUNT NO. "<<account<<"\n\nBALANCE : BDT "<<balance<<"\n\n";
cout<<"\n***************************************\n\n";
}
}
void main()
{
int i,j,k,m,l,y=0;
bank b[20];
int index;
textcolor(0);
textbackground(4);
clrscr();
do
{
cout<<"\a\nPRESS 1 TO OPEN ACCOUNT\n\n"<<"PRESS 2 TO DEPOSITE AMOUNT\n\n"<<"PRESS 3 TO WITHDRAW MONEY \n\n"<<"PRESS 4 TO DISPLAY \n\n"<<"PRESS 5 TO SEARCH \n\n"<<"PRESS 6 TO EXIT \n\n\t\n";
cout<<"Your option......";
cin>>index;
switch(index)
{
case 1:
cout<<"\nHOW MANY ACCOUNT YOU WANT TO OPEN?\n"; //opening account
cin>>y;
for(i=0;i<y;i++)
b[i].open();
break;
case 2:
cout<<"\nENTER YOUR ACCOUNT NO. "; //deposite amount
cin>>j;
for(i=0;i<y;i++)
{
b[i].deposite(j);
}
break;
case 3:
cout<<"\nENTER YOUR ACCOUNT NO. "; //withdraw money
cin>>k;
for(i=0;i<y;i++)
{
b[i].withdraw(k);
}
break;
case 4:
for(i=0;i<y;i++)
{ //display option
b[i].display();
}
break;
case 5:
cout<<"\nENTER YOUR ACCOUNT NO. "; //search option
cin>>m;
for(i=0;i<y;i++)
{
b[i].search(m);
}
break;
case 6:
break;
default:cout<<"\nYOU HAVE PRESSED THE WRONG KEY. PLEASE TRY AGAIN. \n\n\n";
break;
}
} while(index!=6);
} | [
"noreply@github.com"
] | noreply@github.com |
c049044f0af060720c666ed7ad2bc852f77a32c7 | bb2d45152b6fc2ebe9d1a264175369f75fb5d024 | /Arcane/src/Arcane/Vendor/renderdoc-1.x/renderdoc/driver/d3d12/d3d12_command_list4_wrap.cpp | f1d26cd4df69ab403f479f1cd88e57394b437882 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | Ershany/Arcane-Engine | b719930e7538dcb99185fa31e0255fd2d2b2383b | 94ae49d04359bb79916f61fe7c2130939f88f49d | refs/heads/master | 2023-07-27T04:38:23.753293 | 2023-07-23T22:13:48 | 2023-07-23T22:13:48 | 66,559,567 | 492 | 42 | MIT | 2023-07-15T12:33:51 | 2016-08-25T13:20:39 | C++ | UTF-8 | C++ | false | false | 22,629 | cpp | /******************************************************************************
* The MIT License (MIT)
*
* Copyright (c) 2019-2022 Baldur Karlsson
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
******************************************************************************/
#include "d3d12_command_list.h"
#include "d3d12_debug.h"
static rdcstr ToHumanStr(const D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE &el)
{
BEGIN_ENUM_STRINGISE(D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE);
{
case D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD: return "Discard";
case D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE: return "Preserve";
case D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR: return "Clear";
case D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS: return "None";
}
END_ENUM_STRINGISE();
}
static rdcstr ToHumanStr(const D3D12_RENDER_PASS_ENDING_ACCESS_TYPE &el)
{
BEGIN_ENUM_STRINGISE(D3D12_RENDER_PASS_ENDING_ACCESS_TYPE);
{
case D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD: return "Discard";
case D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE: return "Preserve";
case D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE: return "Resolve";
case D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS: return "None";
}
END_ENUM_STRINGISE();
}
static rdcstr MakeRenderPassOpString(bool ending, UINT NumRenderTargets,
const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets,
const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil,
D3D12_RENDER_PASS_FLAGS Flags)
{
rdcstr opDesc = "";
if(NumRenderTargets == 0 && pDepthStencil == NULL)
{
opDesc = "-";
}
else
{
bool colsame = true;
// look through all other color attachments to see if they're identical
for(UINT i = 1; i < NumRenderTargets; i++)
{
if(ending)
{
if(pRenderTargets[i].EndingAccess.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS)
continue;
if(pRenderTargets[i].EndingAccess.Type != pRenderTargets[0].EndingAccess.Type)
colsame = false;
}
else
{
if(pRenderTargets[i].BeginningAccess.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS)
continue;
if(pRenderTargets[i].BeginningAccess.Type != pRenderTargets[0].BeginningAccess.Type)
colsame = false;
}
}
// handle depth only passes
if(NumRenderTargets == 0)
{
opDesc = "";
}
else if(!colsame)
{
// if we have different storage for the colour, don't display
// the full details
opDesc = ending ? "Different end op" : "Different begin op";
}
else
{
// all colour ops are the same, print it
opDesc = ending ? ToHumanStr(pRenderTargets[0].EndingAccess.Type)
: ToHumanStr(pRenderTargets[0].BeginningAccess.Type);
}
// do we have depth?
if(pDepthStencil)
{
// could be empty if this is a depth-only pass
if(!opDesc.empty())
opDesc = "C=" + opDesc + ", ";
// if there's no stencil, just print depth op
if(pDepthStencil->StencilBeginningAccess.Type ==
D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS &&
pDepthStencil->StencilEndingAccess.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS)
{
opDesc += "D=" + (ending ? ToHumanStr(pDepthStencil->DepthEndingAccess.Type)
: ToHumanStr(pDepthStencil->DepthBeginningAccess.Type));
}
else
{
if(ending)
{
// if depth and stencil have same op, print together, otherwise separately
if(pDepthStencil->StencilEndingAccess.Type == pDepthStencil->DepthEndingAccess.Type)
opDesc += "DS=" + ToHumanStr(pDepthStencil->DepthEndingAccess.Type);
else
opDesc += "D=" + ToHumanStr(pDepthStencil->DepthEndingAccess.Type) + ", S=" +
ToHumanStr(pDepthStencil->StencilEndingAccess.Type);
}
else
{
// if depth and stencil have same op, print together, otherwise separately
if(pDepthStencil->StencilBeginningAccess.Type == pDepthStencil->DepthBeginningAccess.Type)
opDesc += "DS=" + ToHumanStr(pDepthStencil->DepthBeginningAccess.Type);
else
opDesc += "D=" + ToHumanStr(pDepthStencil->DepthBeginningAccess.Type) + ", S=" +
ToHumanStr(pDepthStencil->StencilBeginningAccess.Type);
}
}
}
}
if(ending && (Flags & D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS))
opDesc = "Suspend, " + opDesc;
if(!ending && (Flags & D3D12_RENDER_PASS_FLAG_RESUMING_PASS))
opDesc = "Resume, " + opDesc;
return opDesc;
}
template <typename SerialiserType>
bool WrappedID3D12GraphicsCommandList::Serialise_BeginRenderPass(
SerialiserType &ser, UINT NumRenderTargets,
const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets,
const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, D3D12_RENDER_PASS_FLAGS Flags)
{
ID3D12GraphicsCommandList4 *pCommandList = this;
SERIALISE_ELEMENT(pCommandList);
SERIALISE_ELEMENT(NumRenderTargets).Important();
SERIALISE_ELEMENT_ARRAY(pRenderTargets, NumRenderTargets);
SERIALISE_ELEMENT_OPT(pDepthStencil);
SERIALISE_ELEMENT(Flags);
// since CPU handles are consumed in the call, we need to read out and serialise the contents
// here.
rdcarray<D3D12Descriptor> RTVs;
D3D12Descriptor DSV;
{
if(ser.IsWriting())
{
for(UINT i = 0; i < NumRenderTargets; i++)
RTVs.push_back(*GetWrapped(pRenderTargets[i].cpuDescriptor));
}
// read and serialise the D3D12Descriptor contents directly, as the call has semantics of
// consuming the descriptor immediately
SERIALISE_ELEMENT(RTVs).Named("RenderTargetDescriptors"_lit);
}
{
// read and serialise the D3D12Descriptor contents directly, as the call has semantics of
// consuming the descriptor immediately.
const D3D12Descriptor *pDSV = NULL;
if(ser.IsWriting())
pDSV = pDepthStencil ? GetWrapped(pDepthStencil->cpuDescriptor) : NULL;
SERIALISE_ELEMENT_OPT(pDSV).Named("DepthStencilDescriptor"_lit);
if(pDSV)
DSV = *pDSV;
}
SERIALISE_CHECK_READ_ERRORS();
if(IsReplayingAndReading())
{
if(GetWrapped(pCommandList)->GetReal4() == NULL)
{
RDCERR("Can't replay ID3D12GraphicsCommandList4 command");
return false;
}
m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList));
// patch the parameters so that we point into our local CPU descriptor handles that are up
// to date
{
D3D12_RENDER_PASS_RENDER_TARGET_DESC *rts =
(D3D12_RENDER_PASS_RENDER_TARGET_DESC *)pRenderTargets;
D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *ds =
(D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *)pDepthStencil;
for(UINT i = 0; i < NumRenderTargets; i++)
rts[i].cpuDescriptor = Unwrap(m_pDevice->GetDebugManager()->GetTempDescriptor(RTVs[i], i));
if(ds)
ds->cpuDescriptor = Unwrap(m_pDevice->GetDebugManager()->GetTempDescriptor(DSV));
}
bool stateUpdate = false;
if(IsActiveReplaying(m_State))
{
if(m_Cmd->InRerecordRange(m_Cmd->m_LastCmdListID))
{
// perform any clears needed
if((Flags & D3D12_RENDER_PASS_FLAG_RESUMING_PASS) == 0)
{
for(UINT i = 0; i < NumRenderTargets; i++)
{
if(pRenderTargets[i].BeginningAccess.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR)
{
Unwrap(m_Cmd->RerecordCmdList(m_Cmd->m_LastCmdListID))
->ClearRenderTargetView(pRenderTargets[i].cpuDescriptor,
pRenderTargets[i].BeginningAccess.Clear.ClearValue.Color,
0, NULL);
}
}
if(pDepthStencil)
{
D3D12_CLEAR_FLAGS flags = {};
if(pDepthStencil->DepthBeginningAccess.Type ==
D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR)
flags |= D3D12_CLEAR_FLAG_DEPTH;
if(pDepthStencil->StencilBeginningAccess.Type ==
D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR)
flags |= D3D12_CLEAR_FLAG_STENCIL;
if(flags != 0)
{
// we can safely read from either depth/stencil clear values because if the access
// type isn't clear the corresponding flag will be unset - so whatever garbage value
// we have isn't used.
Unwrap(m_Cmd->RerecordCmdList(m_Cmd->m_LastCmdListID))
->ClearDepthStencilView(
pDepthStencil->cpuDescriptor, flags,
pDepthStencil->DepthBeginningAccess.Clear.ClearValue.DepthStencil.Depth,
pDepthStencil->StencilBeginningAccess.Clear.ClearValue.DepthStencil.Stencil,
0, NULL);
}
}
}
{
D3D12_CPU_DESCRIPTOR_HANDLE rtHandles[8];
D3D12_CPU_DESCRIPTOR_HANDLE dsvHandle = {};
if(pDepthStencil)
dsvHandle = pDepthStencil->cpuDescriptor;
for(UINT i = 0; i < NumRenderTargets; i++)
rtHandles[i] = pRenderTargets[i].cpuDescriptor;
// need to unwrap here, as FromPortableHandle unwraps too.
Unwrap(m_Cmd->RerecordCmdList(m_Cmd->m_LastCmdListID))
->OMSetRenderTargets(NumRenderTargets, rtHandles, FALSE,
dsvHandle.ptr ? &dsvHandle : NULL);
}
// Unwrap4(m_Cmd->RerecordCmdList(m_Cmd->m_LastCmdListID))->BeginRenderPass(NumRenderTargets,
// pRenderTargets, pDepthStencil, Flags);
if(m_Cmd->IsPartialCmdList(m_Cmd->m_LastCmdListID))
{
m_Cmd->m_Partial[D3D12CommandData::Primary].renderPassActive = true;
}
stateUpdate = true;
}
else if(!m_Cmd->IsPartialCmdList(m_Cmd->m_LastCmdListID))
{
stateUpdate = true;
}
}
else
{
for(UINT i = 0; i < NumRenderTargets; i++)
{
if(pRenderTargets[i].BeginningAccess.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR)
{
Unwrap(pCommandList)
->ClearRenderTargetView(pRenderTargets[i].cpuDescriptor,
pRenderTargets[i].BeginningAccess.Clear.ClearValue.Color, 0,
NULL);
}
}
if(pDepthStencil)
{
D3D12_CLEAR_FLAGS flags = {};
if(pDepthStencil->DepthBeginningAccess.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR)
flags |= D3D12_CLEAR_FLAG_DEPTH;
if(pDepthStencil->StencilBeginningAccess.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR)
flags |= D3D12_CLEAR_FLAG_STENCIL;
if(flags != 0)
{
// we can safely read from either depth/stencil clear values because if the access
// type isn't clear the corresponding flag will be unset - so whatever garbage value
// we have isn't used.
Unwrap(pCommandList)
->ClearDepthStencilView(
pDepthStencil->cpuDescriptor, flags,
pDepthStencil->DepthBeginningAccess.Clear.ClearValue.DepthStencil.Depth,
pDepthStencil->StencilBeginningAccess.Clear.ClearValue.DepthStencil.Stencil, 0,
NULL);
}
}
D3D12_CPU_DESCRIPTOR_HANDLE rtHandles[8];
D3D12_CPU_DESCRIPTOR_HANDLE dsvHandle = {};
if(pDepthStencil)
dsvHandle = pDepthStencil->cpuDescriptor;
for(UINT i = 0; i < NumRenderTargets; i++)
rtHandles[i] = pRenderTargets[i].cpuDescriptor;
// need to unwrap here, as FromPortableHandle unwraps too.
Unwrap(pCommandList)
->OMSetRenderTargets(NumRenderTargets, rtHandles, FALSE, dsvHandle.ptr ? &dsvHandle : NULL);
GetCrackedList()->OMSetRenderTargets(NumRenderTargets, rtHandles, FALSE,
dsvHandle.ptr ? &dsvHandle : NULL);
// Unwrap4(pCommandList)->BeginRenderPass(NumRenderTargets, pRenderTargets, pDepthStencil,
// Flags);
// GetCrackedList4()->BeginRenderPass(NumRenderTargets, pRenderTargets, pDepthStencil, Flags);
m_Cmd->AddEvent();
ActionDescription action;
action.customName = StringFormat::Fmt(
"BeginRenderPass(%s)",
MakeRenderPassOpString(false, NumRenderTargets, pRenderTargets, pDepthStencil, Flags).c_str());
action.flags |= ActionFlags::BeginPass | ActionFlags::PassBoundary;
m_Cmd->AddAction(action);
stateUpdate = true;
}
if(stateUpdate)
{
D3D12RenderState &state = m_Cmd->m_BakedCmdListInfo[m_Cmd->m_LastCmdListID].state;
state.rts = RTVs;
state.dsv = DSV;
state.renderpass = true;
state.rpRTs.resize(NumRenderTargets);
for(UINT r = 0; r < NumRenderTargets; r++)
state.rpRTs[r] = pRenderTargets[r];
state.rpDSV = {};
if(pDepthStencil)
state.rpDSV = *pDepthStencil;
state.rpFlags = Flags;
}
}
return true;
}
void WrappedID3D12GraphicsCommandList::BeginRenderPass(
UINT NumRenderTargets, const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets,
const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, D3D12_RENDER_PASS_FLAGS Flags)
{
D3D12_RENDER_PASS_RENDER_TARGET_DESC *unwrappedRTs =
m_pDevice->GetTempArray<D3D12_RENDER_PASS_RENDER_TARGET_DESC>(NumRenderTargets);
for(UINT i = 0; i < NumRenderTargets; i++)
{
unwrappedRTs[i] = pRenderTargets[i];
unwrappedRTs[i].cpuDescriptor = Unwrap(unwrappedRTs[i].cpuDescriptor);
}
D3D12_RENDER_PASS_DEPTH_STENCIL_DESC unwrappedDSV;
if(pDepthStencil)
{
unwrappedDSV = *pDepthStencil;
unwrappedDSV.cpuDescriptor = Unwrap(unwrappedDSV.cpuDescriptor);
}
SERIALISE_TIME_CALL(m_pList4->BeginRenderPass(NumRenderTargets, unwrappedRTs,
pDepthStencil ? &unwrappedDSV : NULL, Flags));
if(IsCaptureMode(m_State))
{
CACHE_THREAD_SERIALISER();
SCOPED_SERIALISE_CHUNK(D3D12Chunk::List_BeginRenderPass);
Serialise_BeginRenderPass(ser, NumRenderTargets, pRenderTargets, pDepthStencil, Flags);
m_ListRecord->AddChunk(scope.Get(m_ListRecord->cmdInfo->alloc));
for(UINT i = 0; i < NumRenderTargets; i++)
{
D3D12Descriptor *desc = GetWrapped(pRenderTargets[i].cpuDescriptor);
m_ListRecord->MarkResourceFrameReferenced(desc->GetHeapResourceId(), eFrameRef_Read);
m_ListRecord->MarkResourceFrameReferenced(desc->GetResResourceId(), eFrameRef_PartialWrite);
if(pRenderTargets[i].EndingAccess.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE)
{
m_ListRecord->MarkResourceFrameReferenced(
GetResID(pRenderTargets[i].EndingAccess.Resolve.pSrcResource), eFrameRef_PartialWrite);
m_ListRecord->MarkResourceFrameReferenced(
GetResID(pRenderTargets[i].EndingAccess.Resolve.pDstResource), eFrameRef_PartialWrite);
}
}
if(pDepthStencil)
{
D3D12Descriptor *desc = GetWrapped(pDepthStencil->cpuDescriptor);
m_ListRecord->MarkResourceFrameReferenced(desc->GetHeapResourceId(), eFrameRef_Read);
m_ListRecord->MarkResourceFrameReferenced(desc->GetResResourceId(), eFrameRef_PartialWrite);
if(pDepthStencil->DepthEndingAccess.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE)
{
m_ListRecord->MarkResourceFrameReferenced(
GetResID(pDepthStencil->DepthEndingAccess.Resolve.pSrcResource), eFrameRef_PartialWrite);
m_ListRecord->MarkResourceFrameReferenced(
GetResID(pDepthStencil->DepthEndingAccess.Resolve.pDstResource), eFrameRef_PartialWrite);
}
if(pDepthStencil->StencilEndingAccess.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE)
{
m_ListRecord->MarkResourceFrameReferenced(
GetResID(pDepthStencil->StencilEndingAccess.Resolve.pSrcResource),
eFrameRef_PartialWrite);
m_ListRecord->MarkResourceFrameReferenced(
GetResID(pDepthStencil->StencilEndingAccess.Resolve.pDstResource),
eFrameRef_PartialWrite);
}
}
}
}
template <typename SerialiserType>
bool WrappedID3D12GraphicsCommandList::Serialise_EndRenderPass(SerialiserType &ser)
{
ID3D12GraphicsCommandList4 *pCommandList = this;
SERIALISE_ELEMENT(pCommandList).Unimportant();
SERIALISE_CHECK_READ_ERRORS();
if(IsReplayingAndReading())
{
if(GetWrapped(pCommandList)->GetReal4() == NULL)
{
RDCERR("Can't replay ID3D12GraphicsCommandList4 command");
return false;
}
m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList));
bool stateUpdate = false;
if(IsActiveReplaying(m_State))
{
if(m_Cmd->InRerecordRange(m_Cmd->m_LastCmdListID))
{
// Unwrap4(m_Cmd->RerecordCmdList(m_Cmd->m_LastCmdListID))->EndRenderPass();
if(m_Cmd->IsPartialCmdList(m_Cmd->m_LastCmdListID))
{
m_Cmd->m_Partial[D3D12CommandData::Primary].renderPassActive = false;
}
stateUpdate = true;
}
else if(!m_Cmd->IsPartialCmdList(m_Cmd->m_LastCmdListID))
{
stateUpdate = true;
}
}
else
{
// Unwrap4(pCommandList)->EndRenderPass();
// GetCrackedList4()->EndRenderPass();
m_Cmd->AddEvent();
D3D12RenderState &state = m_Cmd->m_BakedCmdListInfo[m_Cmd->m_LastCmdListID].state;
ActionDescription action;
action.customName = StringFormat::Fmt(
"EndRenderPass(%s)",
MakeRenderPassOpString(true, (UINT)state.rpRTs.size(), state.rpRTs.data(),
state.rpDSV.cpuDescriptor.ptr ? &state.rpDSV : NULL, state.rpFlags)
.c_str());
action.flags |= ActionFlags::EndPass | ActionFlags::PassBoundary;
m_Cmd->AddAction(action);
stateUpdate = true;
}
if(stateUpdate)
{
D3D12RenderState &state = m_Cmd->m_BakedCmdListInfo[m_Cmd->m_LastCmdListID].state;
state.rts.clear();
state.dsv = D3D12Descriptor();
state.renderpass = false;
state.rpRTs.clear();
state.rpDSV = {};
state.rpFlags = D3D12_RENDER_PASS_FLAG_NONE;
}
}
return true;
}
void WrappedID3D12GraphicsCommandList::EndRenderPass()
{
SERIALISE_TIME_CALL(m_pList4->EndRenderPass());
if(IsCaptureMode(m_State))
{
CACHE_THREAD_SERIALISER();
SCOPED_SERIALISE_CHUNK(D3D12Chunk::List_EndRenderPass);
Serialise_EndRenderPass(ser);
m_ListRecord->AddChunk(scope.Get(m_ListRecord->cmdInfo->alloc));
}
}
void WrappedID3D12GraphicsCommandList::InitializeMetaCommand(
_In_ ID3D12MetaCommand *pMetaCommand,
_In_reads_bytes_opt_(InitializationParametersDataSizeInBytes)
const void *pInitializationParametersData,
_In_ SIZE_T InitializationParametersDataSizeInBytes)
{
RDCERR("InitializeMetaCommand called but no meta commands reported!");
}
void WrappedID3D12GraphicsCommandList::ExecuteMetaCommand(
_In_ ID3D12MetaCommand *pMetaCommand,
_In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData,
_In_ SIZE_T ExecutionParametersDataSizeInBytes)
{
RDCERR("ExecuteMetaCommand called but no meta commands reported!");
}
void WrappedID3D12GraphicsCommandList::BuildRaytracingAccelerationStructure(
_In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc,
_In_ UINT NumPostbuildInfoDescs,
_In_reads_opt_(NumPostbuildInfoDescs)
const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs)
{
RDCERR("BuildRaytracingAccelerationStructure called but raytracing is not supported!");
}
void WrappedID3D12GraphicsCommandList::EmitRaytracingAccelerationStructurePostbuildInfo(
_In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc,
_In_ UINT NumSourceAccelerationStructures,
_In_reads_(NumSourceAccelerationStructures)
const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData)
{
RDCERR(
"EmitRaytracingAccelerationStructurePostbuildInfo called but raytracing is not supported!");
}
void WrappedID3D12GraphicsCommandList::CopyRaytracingAccelerationStructure(
_In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData,
_In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData,
_In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode)
{
RDCERR("CopyRaytracingAccelerationStructure called but raytracing is not supported!");
}
void WrappedID3D12GraphicsCommandList::SetPipelineState1(_In_ ID3D12StateObject *pStateObject)
{
RDCERR("SetPipelineState1 called but raytracing is not supported!");
}
void WrappedID3D12GraphicsCommandList::DispatchRays(_In_ const D3D12_DISPATCH_RAYS_DESC *pDesc)
{
RDCERR("DispatchRays called but raytracing is not supported!");
}
INSTANTIATE_FUNCTION_SERIALISED(void, WrappedID3D12GraphicsCommandList, BeginRenderPass,
UINT NumRenderTargets,
const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets,
const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil,
D3D12_RENDER_PASS_FLAGS Flags);
INSTANTIATE_FUNCTION_SERIALISED(void, WrappedID3D12GraphicsCommandList, EndRenderPass);
| [
"bradyjessup@hotmail.com"
] | bradyjessup@hotmail.com |
d81421cd60a4bf6d0dce90ebc685ea60dd534a8e | ba1483a46b56ba7a324a3311beb6a16192051ecd | /Library/Il2cppBuildCache/UWP/ARMv7/il2cppOutput/UnityEngine.PhysicsModule.cpp | d362b5d72a9755ed2fe8c785db19a54d342e8e35 | [] | no_license | jbeutel/NASA-SUITS-AR-Displays | b35471ef4977e5b6745a836f71704be289ec32c0 | 0ccbdf27e93267fa105eec457945455331aefeae | refs/heads/main | 2023-04-06T03:56:03.482847 | 2021-05-03T04:07:26 | 2021-05-03T04:07:26 | 367,192,912 | 2 | 0 | null | 2021-05-13T22:51:58 | 2021-05-13T22:51:57 | null | UTF-8 | C++ | false | false | 375,811 | cpp | #include "pch-cpp.hpp"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <limits>
#include <stdint.h>
// System.Char[]
struct CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34;
// UnityEngine.Collider[]
struct ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486;
// UnityEngine.ContactPoint[]
struct ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B;
// System.Object[]
struct ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE;
// UnityEngine.RaycastHit[]
struct RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09;
// UnityEngine.BoxCollider
struct BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5;
// UnityEngine.CapsuleCollider
struct CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635;
// UnityEngine.CharacterController
struct CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E;
// UnityEngine.Collider
struct Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02;
// UnityEngine.Collision
struct Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0;
// UnityEngine.Component
struct Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684;
// UnityEngine.ControllerColliderHit
struct ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550;
// UnityEngine.GameObject
struct GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319;
// UnityEngine.Joint
struct Joint_t085126F36196FC982700F4EA8466CF10C90EC15E;
// UnityEngine.Mesh
struct Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6;
// UnityEngine.MeshCollider
struct MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98;
// UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A;
// UnityEngine.PhysicMaterial
struct PhysicMaterial_tD3D9C84806E95BABF076A74331DF8D9A4B03E3C2;
// UnityEngine.Renderer
struct Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C;
// UnityEngine.Rigidbody
struct Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A;
// UnityEngine.SphereCollider
struct SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A;
// UnityEngine.SpringJoint
struct SpringJoint_t6F2ACC63AD7C975D92271BC2DE2B564087DC27BF;
// System.String
struct String_t;
// UnityEngine.Transform
struct Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1;
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5;
IL2CPP_EXTERN_C RuntimeClass* Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C String_t* _stringLiteral21ACE806CE655297BC379B3AD17E97F0A68B6AEC;
IL2CPP_EXTERN_C const RuntimeMethod* Component_GetComponent_TisRenderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C_m436E5B0F17DDEF3CC61F77DEA82B1A92668AF019_RuntimeMethod_var;
struct ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 ;
struct ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486;
struct ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B;
struct ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE;
struct RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09;
IL2CPP_EXTERN_C_BEGIN
IL2CPP_EXTERN_C_END
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// <Module>
struct U3CModuleU3E_tC43E3828CD23D91917D996FCE04516C5EF9F6DD6
{
public:
public:
};
// System.Object
struct Il2CppArrayBounds;
// System.Array
// UnityEngine.Physics
struct Physics_tED41E76FFDD034FA1B46162C3D283C36814DA0A4 : public RuntimeObject
{
public:
public:
};
// System.String
struct String_t : public RuntimeObject
{
public:
// System.Int32 System.String::m_stringLength
int32_t ___m_stringLength_0;
// System.Char System.String::m_firstChar
Il2CppChar ___m_firstChar_1;
public:
inline static int32_t get_offset_of_m_stringLength_0() { return static_cast<int32_t>(offsetof(String_t, ___m_stringLength_0)); }
inline int32_t get_m_stringLength_0() const { return ___m_stringLength_0; }
inline int32_t* get_address_of_m_stringLength_0() { return &___m_stringLength_0; }
inline void set_m_stringLength_0(int32_t value)
{
___m_stringLength_0 = value;
}
inline static int32_t get_offset_of_m_firstChar_1() { return static_cast<int32_t>(offsetof(String_t, ___m_firstChar_1)); }
inline Il2CppChar get_m_firstChar_1() const { return ___m_firstChar_1; }
inline Il2CppChar* get_address_of_m_firstChar_1() { return &___m_firstChar_1; }
inline void set_m_firstChar_1(Il2CppChar value)
{
___m_firstChar_1 = value;
}
};
struct String_t_StaticFields
{
public:
// System.String System.String::Empty
String_t* ___Empty_5;
public:
inline static int32_t get_offset_of_Empty_5() { return static_cast<int32_t>(offsetof(String_t_StaticFields, ___Empty_5)); }
inline String_t* get_Empty_5() const { return ___Empty_5; }
inline String_t** get_address_of_Empty_5() { return &___Empty_5; }
inline void set_Empty_5(String_t* value)
{
___Empty_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Empty_5), (void*)value);
}
};
// System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52 : public RuntimeObject
{
public:
public:
};
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_com
{
};
// System.Boolean
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TrueString_5), (void*)value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FalseString_6), (void*)value);
}
};
// System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA : public ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52
{
public:
public:
};
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___enumSeperatorCharArray_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_com
{
};
// System.Int32
struct Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046
{
public:
// System.Int32 System.Int32::m_value
int32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046, ___m_value_0)); }
inline int32_t get_m_value_0() const { return ___m_value_0; }
inline int32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int32_t value)
{
___m_value_0 = value;
}
};
// System.IntPtr
struct IntPtr_t
{
public:
// System.Void* System.IntPtr::m_value
void* ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(IntPtr_t, ___m_value_0)); }
inline void* get_m_value_0() const { return ___m_value_0; }
inline void** get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(void* value)
{
___m_value_0 = value;
}
};
struct IntPtr_t_StaticFields
{
public:
// System.IntPtr System.IntPtr::Zero
intptr_t ___Zero_1;
public:
inline static int32_t get_offset_of_Zero_1() { return static_cast<int32_t>(offsetof(IntPtr_t_StaticFields, ___Zero_1)); }
inline intptr_t get_Zero_1() const { return ___Zero_1; }
inline intptr_t* get_address_of_Zero_1() { return &___Zero_1; }
inline void set_Zero_1(intptr_t value)
{
___Zero_1 = value;
}
};
// UnityEngine.PhysicsScene
struct PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678
{
public:
// System.Int32 UnityEngine.PhysicsScene::m_Handle
int32_t ___m_Handle_0;
public:
inline static int32_t get_offset_of_m_Handle_0() { return static_cast<int32_t>(offsetof(PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678, ___m_Handle_0)); }
inline int32_t get_m_Handle_0() const { return ___m_Handle_0; }
inline int32_t* get_address_of_m_Handle_0() { return &___m_Handle_0; }
inline void set_m_Handle_0(int32_t value)
{
___m_Handle_0 = value;
}
};
// UnityEngine.Quaternion
struct Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4
{
public:
// System.Single UnityEngine.Quaternion::x
float ___x_0;
// System.Single UnityEngine.Quaternion::y
float ___y_1;
// System.Single UnityEngine.Quaternion::z
float ___z_2;
// System.Single UnityEngine.Quaternion::w
float ___w_3;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___x_0)); }
inline float get_x_0() const { return ___x_0; }
inline float* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(float value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___y_1)); }
inline float get_y_1() const { return ___y_1; }
inline float* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(float value)
{
___y_1 = value;
}
inline static int32_t get_offset_of_z_2() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___z_2)); }
inline float get_z_2() const { return ___z_2; }
inline float* get_address_of_z_2() { return &___z_2; }
inline void set_z_2(float value)
{
___z_2 = value;
}
inline static int32_t get_offset_of_w_3() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___w_3)); }
inline float get_w_3() const { return ___w_3; }
inline float* get_address_of_w_3() { return &___w_3; }
inline void set_w_3(float value)
{
___w_3 = value;
}
};
struct Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4_StaticFields
{
public:
// UnityEngine.Quaternion UnityEngine.Quaternion::identityQuaternion
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___identityQuaternion_4;
public:
inline static int32_t get_offset_of_identityQuaternion_4() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4_StaticFields, ___identityQuaternion_4)); }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 get_identityQuaternion_4() const { return ___identityQuaternion_4; }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * get_address_of_identityQuaternion_4() { return &___identityQuaternion_4; }
inline void set_identityQuaternion_4(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 value)
{
___identityQuaternion_4 = value;
}
};
// System.Single
struct Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E
{
public:
// System.Single System.Single::m_value
float ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E, ___m_value_0)); }
inline float get_m_value_0() const { return ___m_value_0; }
inline float* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(float value)
{
___m_value_0 = value;
}
};
// System.UInt32
struct UInt32_tE60352A06233E4E69DD198BCC67142159F686B15
{
public:
// System.UInt32 System.UInt32::m_value
uint32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt32_tE60352A06233E4E69DD198BCC67142159F686B15, ___m_value_0)); }
inline uint32_t get_m_value_0() const { return ___m_value_0; }
inline uint32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint32_t value)
{
___m_value_0 = value;
}
};
// UnityEngine.Vector2
struct Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9
{
public:
// System.Single UnityEngine.Vector2::x
float ___x_0;
// System.Single UnityEngine.Vector2::y
float ___y_1;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9, ___x_0)); }
inline float get_x_0() const { return ___x_0; }
inline float* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(float value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9, ___y_1)); }
inline float get_y_1() const { return ___y_1; }
inline float* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(float value)
{
___y_1 = value;
}
};
struct Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields
{
public:
// UnityEngine.Vector2 UnityEngine.Vector2::zeroVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___zeroVector_2;
// UnityEngine.Vector2 UnityEngine.Vector2::oneVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___oneVector_3;
// UnityEngine.Vector2 UnityEngine.Vector2::upVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___upVector_4;
// UnityEngine.Vector2 UnityEngine.Vector2::downVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___downVector_5;
// UnityEngine.Vector2 UnityEngine.Vector2::leftVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___leftVector_6;
// UnityEngine.Vector2 UnityEngine.Vector2::rightVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___rightVector_7;
// UnityEngine.Vector2 UnityEngine.Vector2::positiveInfinityVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___positiveInfinityVector_8;
// UnityEngine.Vector2 UnityEngine.Vector2::negativeInfinityVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___negativeInfinityVector_9;
public:
inline static int32_t get_offset_of_zeroVector_2() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___zeroVector_2)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_zeroVector_2() const { return ___zeroVector_2; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_zeroVector_2() { return &___zeroVector_2; }
inline void set_zeroVector_2(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___zeroVector_2 = value;
}
inline static int32_t get_offset_of_oneVector_3() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___oneVector_3)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_oneVector_3() const { return ___oneVector_3; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_oneVector_3() { return &___oneVector_3; }
inline void set_oneVector_3(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___oneVector_3 = value;
}
inline static int32_t get_offset_of_upVector_4() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___upVector_4)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_upVector_4() const { return ___upVector_4; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_upVector_4() { return &___upVector_4; }
inline void set_upVector_4(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___upVector_4 = value;
}
inline static int32_t get_offset_of_downVector_5() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___downVector_5)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_downVector_5() const { return ___downVector_5; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_downVector_5() { return &___downVector_5; }
inline void set_downVector_5(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___downVector_5 = value;
}
inline static int32_t get_offset_of_leftVector_6() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___leftVector_6)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_leftVector_6() const { return ___leftVector_6; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_leftVector_6() { return &___leftVector_6; }
inline void set_leftVector_6(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___leftVector_6 = value;
}
inline static int32_t get_offset_of_rightVector_7() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___rightVector_7)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_rightVector_7() const { return ___rightVector_7; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_rightVector_7() { return &___rightVector_7; }
inline void set_rightVector_7(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___rightVector_7 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___positiveInfinityVector_8)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_positiveInfinityVector_8() const { return ___positiveInfinityVector_8; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_positiveInfinityVector_8() { return &___positiveInfinityVector_8; }
inline void set_positiveInfinityVector_8(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___positiveInfinityVector_8 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_9() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___negativeInfinityVector_9)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_negativeInfinityVector_9() const { return ___negativeInfinityVector_9; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_negativeInfinityVector_9() { return &___negativeInfinityVector_9; }
inline void set_negativeInfinityVector_9(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___negativeInfinityVector_9 = value;
}
};
// UnityEngine.Vector3
struct Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E
{
public:
// System.Single UnityEngine.Vector3::x
float ___x_2;
// System.Single UnityEngine.Vector3::y
float ___y_3;
// System.Single UnityEngine.Vector3::z
float ___z_4;
public:
inline static int32_t get_offset_of_x_2() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E, ___x_2)); }
inline float get_x_2() const { return ___x_2; }
inline float* get_address_of_x_2() { return &___x_2; }
inline void set_x_2(float value)
{
___x_2 = value;
}
inline static int32_t get_offset_of_y_3() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E, ___y_3)); }
inline float get_y_3() const { return ___y_3; }
inline float* get_address_of_y_3() { return &___y_3; }
inline void set_y_3(float value)
{
___y_3 = value;
}
inline static int32_t get_offset_of_z_4() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E, ___z_4)); }
inline float get_z_4() const { return ___z_4; }
inline float* get_address_of_z_4() { return &___z_4; }
inline void set_z_4(float value)
{
___z_4 = value;
}
};
struct Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields
{
public:
// UnityEngine.Vector3 UnityEngine.Vector3::zeroVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___zeroVector_5;
// UnityEngine.Vector3 UnityEngine.Vector3::oneVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___oneVector_6;
// UnityEngine.Vector3 UnityEngine.Vector3::upVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___upVector_7;
// UnityEngine.Vector3 UnityEngine.Vector3::downVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___downVector_8;
// UnityEngine.Vector3 UnityEngine.Vector3::leftVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___leftVector_9;
// UnityEngine.Vector3 UnityEngine.Vector3::rightVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___rightVector_10;
// UnityEngine.Vector3 UnityEngine.Vector3::forwardVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___forwardVector_11;
// UnityEngine.Vector3 UnityEngine.Vector3::backVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___backVector_12;
// UnityEngine.Vector3 UnityEngine.Vector3::positiveInfinityVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___positiveInfinityVector_13;
// UnityEngine.Vector3 UnityEngine.Vector3::negativeInfinityVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___negativeInfinityVector_14;
public:
inline static int32_t get_offset_of_zeroVector_5() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___zeroVector_5)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_zeroVector_5() const { return ___zeroVector_5; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_zeroVector_5() { return &___zeroVector_5; }
inline void set_zeroVector_5(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___zeroVector_5 = value;
}
inline static int32_t get_offset_of_oneVector_6() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___oneVector_6)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_oneVector_6() const { return ___oneVector_6; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_oneVector_6() { return &___oneVector_6; }
inline void set_oneVector_6(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___oneVector_6 = value;
}
inline static int32_t get_offset_of_upVector_7() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___upVector_7)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_upVector_7() const { return ___upVector_7; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_upVector_7() { return &___upVector_7; }
inline void set_upVector_7(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___upVector_7 = value;
}
inline static int32_t get_offset_of_downVector_8() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___downVector_8)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_downVector_8() const { return ___downVector_8; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_downVector_8() { return &___downVector_8; }
inline void set_downVector_8(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___downVector_8 = value;
}
inline static int32_t get_offset_of_leftVector_9() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___leftVector_9)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_leftVector_9() const { return ___leftVector_9; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_leftVector_9() { return &___leftVector_9; }
inline void set_leftVector_9(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___leftVector_9 = value;
}
inline static int32_t get_offset_of_rightVector_10() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___rightVector_10)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_rightVector_10() const { return ___rightVector_10; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_rightVector_10() { return &___rightVector_10; }
inline void set_rightVector_10(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___rightVector_10 = value;
}
inline static int32_t get_offset_of_forwardVector_11() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___forwardVector_11)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_forwardVector_11() const { return ___forwardVector_11; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_forwardVector_11() { return &___forwardVector_11; }
inline void set_forwardVector_11(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___forwardVector_11 = value;
}
inline static int32_t get_offset_of_backVector_12() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___backVector_12)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_backVector_12() const { return ___backVector_12; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_backVector_12() { return &___backVector_12; }
inline void set_backVector_12(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___backVector_12 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_13() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___positiveInfinityVector_13)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_positiveInfinityVector_13() const { return ___positiveInfinityVector_13; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_positiveInfinityVector_13() { return &___positiveInfinityVector_13; }
inline void set_positiveInfinityVector_13(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___positiveInfinityVector_13 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_14() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___negativeInfinityVector_14)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_negativeInfinityVector_14() const { return ___negativeInfinityVector_14; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_negativeInfinityVector_14() { return &___negativeInfinityVector_14; }
inline void set_negativeInfinityVector_14(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___negativeInfinityVector_14 = value;
}
};
// UnityEngine.Vector4
struct Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7
{
public:
// System.Single UnityEngine.Vector4::x
float ___x_1;
// System.Single UnityEngine.Vector4::y
float ___y_2;
// System.Single UnityEngine.Vector4::z
float ___z_3;
// System.Single UnityEngine.Vector4::w
float ___w_4;
public:
inline static int32_t get_offset_of_x_1() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7, ___x_1)); }
inline float get_x_1() const { return ___x_1; }
inline float* get_address_of_x_1() { return &___x_1; }
inline void set_x_1(float value)
{
___x_1 = value;
}
inline static int32_t get_offset_of_y_2() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7, ___y_2)); }
inline float get_y_2() const { return ___y_2; }
inline float* get_address_of_y_2() { return &___y_2; }
inline void set_y_2(float value)
{
___y_2 = value;
}
inline static int32_t get_offset_of_z_3() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7, ___z_3)); }
inline float get_z_3() const { return ___z_3; }
inline float* get_address_of_z_3() { return &___z_3; }
inline void set_z_3(float value)
{
___z_3 = value;
}
inline static int32_t get_offset_of_w_4() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7, ___w_4)); }
inline float get_w_4() const { return ___w_4; }
inline float* get_address_of_w_4() { return &___w_4; }
inline void set_w_4(float value)
{
___w_4 = value;
}
};
struct Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7_StaticFields
{
public:
// UnityEngine.Vector4 UnityEngine.Vector4::zeroVector
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___zeroVector_5;
// UnityEngine.Vector4 UnityEngine.Vector4::oneVector
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___oneVector_6;
// UnityEngine.Vector4 UnityEngine.Vector4::positiveInfinityVector
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___positiveInfinityVector_7;
// UnityEngine.Vector4 UnityEngine.Vector4::negativeInfinityVector
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___negativeInfinityVector_8;
public:
inline static int32_t get_offset_of_zeroVector_5() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7_StaticFields, ___zeroVector_5)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_zeroVector_5() const { return ___zeroVector_5; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_zeroVector_5() { return &___zeroVector_5; }
inline void set_zeroVector_5(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___zeroVector_5 = value;
}
inline static int32_t get_offset_of_oneVector_6() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7_StaticFields, ___oneVector_6)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_oneVector_6() const { return ___oneVector_6; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_oneVector_6() { return &___oneVector_6; }
inline void set_oneVector_6(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___oneVector_6 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_7() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7_StaticFields, ___positiveInfinityVector_7)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_positiveInfinityVector_7() const { return ___positiveInfinityVector_7; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_positiveInfinityVector_7() { return &___positiveInfinityVector_7; }
inline void set_positiveInfinityVector_7(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___positiveInfinityVector_7 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7_StaticFields, ___negativeInfinityVector_8)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_negativeInfinityVector_8() const { return ___negativeInfinityVector_8; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_negativeInfinityVector_8() { return &___negativeInfinityVector_8; }
inline void set_negativeInfinityVector_8(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___negativeInfinityVector_8 = value;
}
};
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5
{
public:
union
{
struct
{
};
uint8_t Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5__padding[1];
};
public:
};
// UnityEngine.Bounds
struct Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37
{
public:
// UnityEngine.Vector3 UnityEngine.Bounds::m_Center
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Center_0;
// UnityEngine.Vector3 UnityEngine.Bounds::m_Extents
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Extents_1;
public:
inline static int32_t get_offset_of_m_Center_0() { return static_cast<int32_t>(offsetof(Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37, ___m_Center_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Center_0() const { return ___m_Center_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Center_0() { return &___m_Center_0; }
inline void set_m_Center_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Center_0 = value;
}
inline static int32_t get_offset_of_m_Extents_1() { return static_cast<int32_t>(offsetof(Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37, ___m_Extents_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Extents_1() const { return ___m_Extents_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Extents_1() { return &___m_Extents_1; }
inline void set_m_Extents_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Extents_1 = value;
}
};
// UnityEngine.Collision
struct Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0 : public RuntimeObject
{
public:
// UnityEngine.Vector3 UnityEngine.Collision::m_Impulse
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Impulse_0;
// UnityEngine.Vector3 UnityEngine.Collision::m_RelativeVelocity
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_RelativeVelocity_1;
// UnityEngine.Rigidbody UnityEngine.Collision::m_Rigidbody
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * ___m_Rigidbody_2;
// UnityEngine.Collider UnityEngine.Collision::m_Collider
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___m_Collider_3;
// System.Int32 UnityEngine.Collision::m_ContactCount
int32_t ___m_ContactCount_4;
// UnityEngine.ContactPoint[] UnityEngine.Collision::m_ReusedContacts
ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* ___m_ReusedContacts_5;
// UnityEngine.ContactPoint[] UnityEngine.Collision::m_LegacyContacts
ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* ___m_LegacyContacts_6;
public:
inline static int32_t get_offset_of_m_Impulse_0() { return static_cast<int32_t>(offsetof(Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0, ___m_Impulse_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Impulse_0() const { return ___m_Impulse_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Impulse_0() { return &___m_Impulse_0; }
inline void set_m_Impulse_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Impulse_0 = value;
}
inline static int32_t get_offset_of_m_RelativeVelocity_1() { return static_cast<int32_t>(offsetof(Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0, ___m_RelativeVelocity_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_RelativeVelocity_1() const { return ___m_RelativeVelocity_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_RelativeVelocity_1() { return &___m_RelativeVelocity_1; }
inline void set_m_RelativeVelocity_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_RelativeVelocity_1 = value;
}
inline static int32_t get_offset_of_m_Rigidbody_2() { return static_cast<int32_t>(offsetof(Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0, ___m_Rigidbody_2)); }
inline Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * get_m_Rigidbody_2() const { return ___m_Rigidbody_2; }
inline Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A ** get_address_of_m_Rigidbody_2() { return &___m_Rigidbody_2; }
inline void set_m_Rigidbody_2(Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * value)
{
___m_Rigidbody_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Rigidbody_2), (void*)value);
}
inline static int32_t get_offset_of_m_Collider_3() { return static_cast<int32_t>(offsetof(Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0, ___m_Collider_3)); }
inline Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * get_m_Collider_3() const { return ___m_Collider_3; }
inline Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 ** get_address_of_m_Collider_3() { return &___m_Collider_3; }
inline void set_m_Collider_3(Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * value)
{
___m_Collider_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Collider_3), (void*)value);
}
inline static int32_t get_offset_of_m_ContactCount_4() { return static_cast<int32_t>(offsetof(Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0, ___m_ContactCount_4)); }
inline int32_t get_m_ContactCount_4() const { return ___m_ContactCount_4; }
inline int32_t* get_address_of_m_ContactCount_4() { return &___m_ContactCount_4; }
inline void set_m_ContactCount_4(int32_t value)
{
___m_ContactCount_4 = value;
}
inline static int32_t get_offset_of_m_ReusedContacts_5() { return static_cast<int32_t>(offsetof(Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0, ___m_ReusedContacts_5)); }
inline ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* get_m_ReusedContacts_5() const { return ___m_ReusedContacts_5; }
inline ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B** get_address_of_m_ReusedContacts_5() { return &___m_ReusedContacts_5; }
inline void set_m_ReusedContacts_5(ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* value)
{
___m_ReusedContacts_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_ReusedContacts_5), (void*)value);
}
inline static int32_t get_offset_of_m_LegacyContacts_6() { return static_cast<int32_t>(offsetof(Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0, ___m_LegacyContacts_6)); }
inline ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* get_m_LegacyContacts_6() const { return ___m_LegacyContacts_6; }
inline ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B** get_address_of_m_LegacyContacts_6() { return &___m_LegacyContacts_6; }
inline void set_m_LegacyContacts_6(ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* value)
{
___m_LegacyContacts_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_LegacyContacts_6), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Collision
struct Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshaled_pinvoke
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Impulse_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_RelativeVelocity_1;
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * ___m_Rigidbody_2;
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___m_Collider_3;
int32_t ___m_ContactCount_4;
ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * ___m_ReusedContacts_5;
ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * ___m_LegacyContacts_6;
};
// Native definition for COM marshalling of UnityEngine.Collision
struct Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshaled_com
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Impulse_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_RelativeVelocity_1;
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * ___m_Rigidbody_2;
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___m_Collider_3;
int32_t ___m_ContactCount_4;
ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * ___m_ReusedContacts_5;
ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * ___m_LegacyContacts_6;
};
// UnityEngine.CollisionFlags
struct CollisionFlags_t435530D092E80B20FFD0DA008B4F298BF224B903
{
public:
// System.Int32 UnityEngine.CollisionFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(CollisionFlags_t435530D092E80B20FFD0DA008B4F298BF224B903, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.ContactPoint
struct ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017
{
public:
// UnityEngine.Vector3 UnityEngine.ContactPoint::m_Point
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Point_0;
// UnityEngine.Vector3 UnityEngine.ContactPoint::m_Normal
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Normal_1;
// System.Int32 UnityEngine.ContactPoint::m_ThisColliderInstanceID
int32_t ___m_ThisColliderInstanceID_2;
// System.Int32 UnityEngine.ContactPoint::m_OtherColliderInstanceID
int32_t ___m_OtherColliderInstanceID_3;
// System.Single UnityEngine.ContactPoint::m_Separation
float ___m_Separation_4;
public:
inline static int32_t get_offset_of_m_Point_0() { return static_cast<int32_t>(offsetof(ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017, ___m_Point_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Point_0() const { return ___m_Point_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Point_0() { return &___m_Point_0; }
inline void set_m_Point_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Point_0 = value;
}
inline static int32_t get_offset_of_m_Normal_1() { return static_cast<int32_t>(offsetof(ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017, ___m_Normal_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Normal_1() const { return ___m_Normal_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Normal_1() { return &___m_Normal_1; }
inline void set_m_Normal_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Normal_1 = value;
}
inline static int32_t get_offset_of_m_ThisColliderInstanceID_2() { return static_cast<int32_t>(offsetof(ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017, ___m_ThisColliderInstanceID_2)); }
inline int32_t get_m_ThisColliderInstanceID_2() const { return ___m_ThisColliderInstanceID_2; }
inline int32_t* get_address_of_m_ThisColliderInstanceID_2() { return &___m_ThisColliderInstanceID_2; }
inline void set_m_ThisColliderInstanceID_2(int32_t value)
{
___m_ThisColliderInstanceID_2 = value;
}
inline static int32_t get_offset_of_m_OtherColliderInstanceID_3() { return static_cast<int32_t>(offsetof(ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017, ___m_OtherColliderInstanceID_3)); }
inline int32_t get_m_OtherColliderInstanceID_3() const { return ___m_OtherColliderInstanceID_3; }
inline int32_t* get_address_of_m_OtherColliderInstanceID_3() { return &___m_OtherColliderInstanceID_3; }
inline void set_m_OtherColliderInstanceID_3(int32_t value)
{
___m_OtherColliderInstanceID_3 = value;
}
inline static int32_t get_offset_of_m_Separation_4() { return static_cast<int32_t>(offsetof(ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017, ___m_Separation_4)); }
inline float get_m_Separation_4() const { return ___m_Separation_4; }
inline float* get_address_of_m_Separation_4() { return &___m_Separation_4; }
inline void set_m_Separation_4(float value)
{
___m_Separation_4 = value;
}
};
// UnityEngine.ControllerColliderHit
struct ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550 : public RuntimeObject
{
public:
// UnityEngine.CharacterController UnityEngine.ControllerColliderHit::m_Controller
CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * ___m_Controller_0;
// UnityEngine.Collider UnityEngine.ControllerColliderHit::m_Collider
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___m_Collider_1;
// UnityEngine.Vector3 UnityEngine.ControllerColliderHit::m_Point
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Point_2;
// UnityEngine.Vector3 UnityEngine.ControllerColliderHit::m_Normal
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Normal_3;
// UnityEngine.Vector3 UnityEngine.ControllerColliderHit::m_MoveDirection
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_MoveDirection_4;
// System.Single UnityEngine.ControllerColliderHit::m_MoveLength
float ___m_MoveLength_5;
// System.Int32 UnityEngine.ControllerColliderHit::m_Push
int32_t ___m_Push_6;
public:
inline static int32_t get_offset_of_m_Controller_0() { return static_cast<int32_t>(offsetof(ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550, ___m_Controller_0)); }
inline CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * get_m_Controller_0() const { return ___m_Controller_0; }
inline CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E ** get_address_of_m_Controller_0() { return &___m_Controller_0; }
inline void set_m_Controller_0(CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * value)
{
___m_Controller_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Controller_0), (void*)value);
}
inline static int32_t get_offset_of_m_Collider_1() { return static_cast<int32_t>(offsetof(ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550, ___m_Collider_1)); }
inline Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * get_m_Collider_1() const { return ___m_Collider_1; }
inline Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 ** get_address_of_m_Collider_1() { return &___m_Collider_1; }
inline void set_m_Collider_1(Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * value)
{
___m_Collider_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Collider_1), (void*)value);
}
inline static int32_t get_offset_of_m_Point_2() { return static_cast<int32_t>(offsetof(ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550, ___m_Point_2)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Point_2() const { return ___m_Point_2; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Point_2() { return &___m_Point_2; }
inline void set_m_Point_2(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Point_2 = value;
}
inline static int32_t get_offset_of_m_Normal_3() { return static_cast<int32_t>(offsetof(ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550, ___m_Normal_3)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Normal_3() const { return ___m_Normal_3; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Normal_3() { return &___m_Normal_3; }
inline void set_m_Normal_3(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Normal_3 = value;
}
inline static int32_t get_offset_of_m_MoveDirection_4() { return static_cast<int32_t>(offsetof(ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550, ___m_MoveDirection_4)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_MoveDirection_4() const { return ___m_MoveDirection_4; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_MoveDirection_4() { return &___m_MoveDirection_4; }
inline void set_m_MoveDirection_4(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_MoveDirection_4 = value;
}
inline static int32_t get_offset_of_m_MoveLength_5() { return static_cast<int32_t>(offsetof(ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550, ___m_MoveLength_5)); }
inline float get_m_MoveLength_5() const { return ___m_MoveLength_5; }
inline float* get_address_of_m_MoveLength_5() { return &___m_MoveLength_5; }
inline void set_m_MoveLength_5(float value)
{
___m_MoveLength_5 = value;
}
inline static int32_t get_offset_of_m_Push_6() { return static_cast<int32_t>(offsetof(ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550, ___m_Push_6)); }
inline int32_t get_m_Push_6() const { return ___m_Push_6; }
inline int32_t* get_address_of_m_Push_6() { return &___m_Push_6; }
inline void set_m_Push_6(int32_t value)
{
___m_Push_6 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.ControllerColliderHit
struct ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshaled_pinvoke
{
CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * ___m_Controller_0;
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___m_Collider_1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Point_2;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Normal_3;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_MoveDirection_4;
float ___m_MoveLength_5;
int32_t ___m_Push_6;
};
// Native definition for COM marshalling of UnityEngine.ControllerColliderHit
struct ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshaled_com
{
CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * ___m_Controller_0;
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___m_Collider_1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Point_2;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Normal_3;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_MoveDirection_4;
float ___m_MoveLength_5;
int32_t ___m_Push_6;
};
// UnityEngine.ForceMode
struct ForceMode_t7778317A4C46140D50D98811D65A7B22E38163D5
{
public:
// System.Int32 UnityEngine.ForceMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ForceMode_t7778317A4C46140D50D98811D65A7B22E38163D5, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Object::m_CachedPtr
intptr_t ___m_CachedPtr_0;
public:
inline static int32_t get_offset_of_m_CachedPtr_0() { return static_cast<int32_t>(offsetof(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A, ___m_CachedPtr_0)); }
inline intptr_t get_m_CachedPtr_0() const { return ___m_CachedPtr_0; }
inline intptr_t* get_address_of_m_CachedPtr_0() { return &___m_CachedPtr_0; }
inline void set_m_CachedPtr_0(intptr_t value)
{
___m_CachedPtr_0 = value;
}
};
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_StaticFields
{
public:
// System.Int32 UnityEngine.Object::OffsetOfInstanceIDInCPlusPlusObject
int32_t ___OffsetOfInstanceIDInCPlusPlusObject_1;
public:
inline static int32_t get_offset_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return static_cast<int32_t>(offsetof(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_StaticFields, ___OffsetOfInstanceIDInCPlusPlusObject_1)); }
inline int32_t get_OffsetOfInstanceIDInCPlusPlusObject_1() const { return ___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline int32_t* get_address_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return &___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline void set_OffsetOfInstanceIDInCPlusPlusObject_1(int32_t value)
{
___OffsetOfInstanceIDInCPlusPlusObject_1 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_pinvoke
{
intptr_t ___m_CachedPtr_0;
};
// Native definition for COM marshalling of UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_com
{
intptr_t ___m_CachedPtr_0;
};
// UnityEngine.QueryTriggerInteraction
struct QueryTriggerInteraction_t9B82FB8CCAF559F47B6B8C0ECE197515ABFA96B0
{
public:
// System.Int32 UnityEngine.QueryTriggerInteraction::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(QueryTriggerInteraction_t9B82FB8CCAF559F47B6B8C0ECE197515ABFA96B0, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Ray
struct Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6
{
public:
// UnityEngine.Vector3 UnityEngine.Ray::m_Origin
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Origin_0;
// UnityEngine.Vector3 UnityEngine.Ray::m_Direction
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Direction_1;
public:
inline static int32_t get_offset_of_m_Origin_0() { return static_cast<int32_t>(offsetof(Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6, ___m_Origin_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Origin_0() const { return ___m_Origin_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Origin_0() { return &___m_Origin_0; }
inline void set_m_Origin_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Origin_0 = value;
}
inline static int32_t get_offset_of_m_Direction_1() { return static_cast<int32_t>(offsetof(Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6, ___m_Direction_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Direction_1() const { return ___m_Direction_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Direction_1() { return &___m_Direction_1; }
inline void set_m_Direction_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Direction_1 = value;
}
};
// UnityEngine.RaycastHit
struct RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89
{
public:
// UnityEngine.Vector3 UnityEngine.RaycastHit::m_Point
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Point_0;
// UnityEngine.Vector3 UnityEngine.RaycastHit::m_Normal
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Normal_1;
// System.UInt32 UnityEngine.RaycastHit::m_FaceID
uint32_t ___m_FaceID_2;
// System.Single UnityEngine.RaycastHit::m_Distance
float ___m_Distance_3;
// UnityEngine.Vector2 UnityEngine.RaycastHit::m_UV
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_UV_4;
// System.Int32 UnityEngine.RaycastHit::m_Collider
int32_t ___m_Collider_5;
public:
inline static int32_t get_offset_of_m_Point_0() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_Point_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Point_0() const { return ___m_Point_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Point_0() { return &___m_Point_0; }
inline void set_m_Point_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Point_0 = value;
}
inline static int32_t get_offset_of_m_Normal_1() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_Normal_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Normal_1() const { return ___m_Normal_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Normal_1() { return &___m_Normal_1; }
inline void set_m_Normal_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Normal_1 = value;
}
inline static int32_t get_offset_of_m_FaceID_2() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_FaceID_2)); }
inline uint32_t get_m_FaceID_2() const { return ___m_FaceID_2; }
inline uint32_t* get_address_of_m_FaceID_2() { return &___m_FaceID_2; }
inline void set_m_FaceID_2(uint32_t value)
{
___m_FaceID_2 = value;
}
inline static int32_t get_offset_of_m_Distance_3() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_Distance_3)); }
inline float get_m_Distance_3() const { return ___m_Distance_3; }
inline float* get_address_of_m_Distance_3() { return &___m_Distance_3; }
inline void set_m_Distance_3(float value)
{
___m_Distance_3 = value;
}
inline static int32_t get_offset_of_m_UV_4() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_UV_4)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_UV_4() const { return ___m_UV_4; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_UV_4() { return &___m_UV_4; }
inline void set_m_UV_4(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_UV_4 = value;
}
inline static int32_t get_offset_of_m_Collider_5() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_Collider_5)); }
inline int32_t get_m_Collider_5() const { return ___m_Collider_5; }
inline int32_t* get_address_of_m_Collider_5() { return &___m_Collider_5; }
inline void set_m_Collider_5(int32_t value)
{
___m_Collider_5 = value;
}
};
// UnityEngine.RigidbodyConstraints
struct RigidbodyConstraints_tB1AC534C460083518E5C8664CE62334E3B5A0F97
{
public:
// System.Int32 UnityEngine.RigidbodyConstraints::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(RigidbodyConstraints_tB1AC534C460083518E5C8664CE62334E3B5A0F97, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Component
struct Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684 : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A
{
public:
public:
};
// UnityEngine.GameObject
struct GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A
{
public:
public:
};
// UnityEngine.Mesh
struct Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A
{
public:
public:
};
// UnityEngine.PhysicMaterial
struct PhysicMaterial_tD3D9C84806E95BABF076A74331DF8D9A4B03E3C2 : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A
{
public:
public:
};
// UnityEngine.Collider
struct Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 : public Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684
{
public:
public:
};
// UnityEngine.Joint
struct Joint_t085126F36196FC982700F4EA8466CF10C90EC15E : public Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684
{
public:
public:
};
// UnityEngine.Renderer
struct Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C : public Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684
{
public:
public:
};
// UnityEngine.Rigidbody
struct Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A : public Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684
{
public:
public:
};
// UnityEngine.Transform
struct Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 : public Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684
{
public:
public:
};
// UnityEngine.BoxCollider
struct BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 : public Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02
{
public:
public:
};
// UnityEngine.CapsuleCollider
struct CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 : public Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02
{
public:
public:
};
// UnityEngine.CharacterController
struct CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E : public Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02
{
public:
public:
};
// UnityEngine.MeshCollider
struct MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 : public Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02
{
public:
public:
};
// UnityEngine.SphereCollider
struct SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A : public Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02
{
public:
public:
};
// UnityEngine.SpringJoint
struct SpringJoint_t6F2ACC63AD7C975D92271BC2DE2B564087DC27BF : public Joint_t085126F36196FC982700F4EA8466CF10C90EC15E
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// UnityEngine.ContactPoint[]
struct ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B : public RuntimeArray
{
public:
ALIGN_FIELD (8) ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 m_Items[1];
public:
inline ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 value)
{
m_Items[index] = value;
}
};
// UnityEngine.RaycastHit[]
struct RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09 : public RuntimeArray
{
public:
ALIGN_FIELD (8) RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 m_Items[1];
public:
inline RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 value)
{
m_Items[index] = value;
}
};
// UnityEngine.Collider[]
struct ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * m_Items[1];
public:
inline Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Object[]
struct ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE : public RuntimeArray
{
public:
ALIGN_FIELD (8) RuntimeObject * m_Items[1];
public:
inline RuntimeObject * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline RuntimeObject ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, RuntimeObject * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline RuntimeObject * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline RuntimeObject ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, RuntimeObject * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// !!0 UnityEngine.Component::GetComponent<System.Object>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * Component_GetComponent_TisRuntimeObject_m69D9C576D6DD024C709E29EEADBC8041299A3AA7_gshared (Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.BoxCollider::get_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void BoxCollider_get_center_Injected_m5F060E93AE651FB756B9371C7A716BDAA2A96F51 (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.BoxCollider::set_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void BoxCollider_set_center_Injected_m54F8740514B14E3B53063FB4C7623BF0F2A48F0A (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.BoxCollider::get_size_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void BoxCollider_get_size_Injected_mC9ABFED6FEC27351BC116B44021578CB39CBCB22 (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.BoxCollider::set_size_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void BoxCollider_set_size_Injected_m7A8B807F4AB573BF955610F55AAD372FF868C967 (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.CapsuleCollider::get_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CapsuleCollider_get_center_Injected_mBDF07E6DE932FBCAF0AA6F167EB993BE03BE6872 (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.CapsuleCollider::set_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CapsuleCollider_set_center_Injected_mB43C17AC81236FB74E61E21215D2145663A7DEEE (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method);
// UnityEngine.CollisionFlags UnityEngine.CharacterController::Move_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t CharacterController_Move_Injected_m6A2168A4CDC70CB62E4A4DCB15A74133E8C6C46D (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___motion0, const RuntimeMethod* method);
// System.Void UnityEngine.CharacterController::get_velocity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CharacterController_get_velocity_Injected_mBECC6B79E09E2530E7CFADB71232589CD15C2A9E (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.Collider::ClosestPoint_Injected(UnityEngine.Vector3&,UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Collider_ClosestPoint_Injected_m6D72FF73D51838EE47234CB4D6234521C08B780D (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___position0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret1, const RuntimeMethod* method);
// System.Void UnityEngine.Collider::get_bounds_Injected(UnityEngine.Bounds&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Collider_get_bounds_Injected_m9BA8C3BC133BC241D571849C4F10F67A951CA962 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.Collider::Raycast_Injected(UnityEngine.Ray&,System.Single,System.Boolean&,UnityEngine.RaycastHit&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Collider_Raycast_Injected_m7176D9E8617D67331E20F519855B8708C63B9E9E (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * ___ray0, float ___maxDistance1, bool* ___hasHit2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___ret3, const RuntimeMethod* method);
// UnityEngine.RaycastHit UnityEngine.Collider::Raycast(UnityEngine.Ray,System.Single,System.Boolean&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 Collider_Raycast_mEB5EDB2C67ABBA9929AE8A898660641E8C82E609 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___maxDistance1, bool* ___hasHit2, const RuntimeMethod* method);
// System.Void UnityEngine.Component::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Component__ctor_m0B00FA207EB3E560B78938D8AD877DB2BC1E3722 (Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684 * __this, const RuntimeMethod* method);
// System.Boolean UnityEngine.Object::op_Inequality(UnityEngine.Object,UnityEngine.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Object_op_Inequality_mE1F187520BD83FB7D86A6D850710C4D42B864E90 (Object_tF2F3778131EFF286AF62B7B013A170F95A91571A * ___x0, Object_tF2F3778131EFF286AF62B7B013A170F95A91571A * ___y1, const RuntimeMethod* method);
// UnityEngine.GameObject UnityEngine.Component::get_gameObject()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * Component_get_gameObject_m55DC35B149AFB9157582755383BA954655FE0C5B (Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684 * __this, const RuntimeMethod* method);
// System.Void System.Array::Copy(System.Array,System.Array,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Array_Copy_m40103AA97DC582C557B912CF4BBE86A4D166F803 (RuntimeArray * ___sourceArray0, RuntimeArray * ___destinationArray1, int32_t ___length2, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.ContactPoint::get_point()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ContactPoint_get_point_mEA976D5E3BC57FAB78F68BE0AA17A97293AEA5BC (ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * __this, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.ContactPoint::get_normal()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ContactPoint_get_normal_m0561937E45F5356C7BB90D861422BD76B36D037A (ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Joint::set_anchor_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Joint_set_anchor_Injected_m036040DCC96FC83B2711CD3A9423AE91DD0C1306 (Joint_t085126F36196FC982700F4EA8466CF10C90EC15E * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.Physics::get_gravity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Physics_get_gravity_Injected_mC0C1A2C9C0490972A162C313425CFC05BDE6C892 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.Physics::get_defaultPhysicsScene_Injected(UnityEngine.PhysicsScene&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Physics_get_defaultPhysicsScene_Injected_m0B71068269B3C8499A258BBCAEA7E3D9D020BADA (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.Physics::IgnoreCollision(UnityEngine.Collider,UnityEngine.Collider,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Physics_IgnoreCollision_m0C99CADD1F937D967C23803147B9C22D6EC428E9 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider10, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider21, bool ___ignore2, const RuntimeMethod* method);
// UnityEngine.PhysicsScene UnityEngine.Physics::get_defaultPhysicsScene()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010 (const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.Ray::get_origin()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * __this, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.Ray::get_direction()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * __this, const RuntimeMethod* method);
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_m2EA572B4613E1BD7DBAA299511CFD2DBA179A163 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.Vector3::op_Subtraction(UnityEngine.Vector3,UnityEngine.Vector3)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Vector3_op_Subtraction_m2725C96965D5C0B1F9715797E51762B13A5FED58_inline (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___a0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___b1, const RuntimeMethod* method);
// System.Single UnityEngine.Vector3::get_magnitude()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float Vector3_get_magnitude_mDDD40612220D8104E77E993E18A101A69A944991 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * __this, const RuntimeMethod* method);
// System.Boolean UnityEngine.Physics::Linecast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Linecast_m0962EAB4C29037847AD41F571E88D54827CDC9A6 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___start0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___end1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::SphereCast(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_SphereCast_m72928994362EE11F9A4F72BD79954444B9FD1C2D (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo3, float ___maxDistance4, int32_t ___layerMask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method);
// System.Boolean UnityEngine.Physics::SphereCast(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_SphereCast_m3179B64AAFD6E888FF0A9CBB967CE342529C333D (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo3, float ___maxDistance4, int32_t ___layerMask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method);
// UnityEngine.RaycastHit[] UnityEngine.Physics::Internal_RaycastAll_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_Internal_RaycastAll_Injected_mD4C3E8762D9FCEE654CE0415E636EB7DBEC92A5B (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * ___ray1, float ___maxDistance2, int32_t ___mask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.Vector3::op_Division(UnityEngine.Vector3,System.Single)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Vector3_op_Division_mE5ACBFB168FED529587457A83BA98B7DB32E2A05_inline (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___a0, float ___d1, const RuntimeMethod* method);
// System.Void UnityEngine.Ray::.ctor(UnityEngine.Vector3,UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Ray__ctor_m75B1F651FF47EE6B887105101B7DA61CBF41F83C (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, const RuntimeMethod* method);
// UnityEngine.RaycastHit[] UnityEngine.Physics::Internal_RaycastAll(UnityEngine.PhysicsScene,UnityEngine.Ray,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_Internal_RaycastAll_m39EE7CF896F9D8BA58CC623F14E4DB0641480523 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray1, float ___maxDistance2, int32_t ___mask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// UnityEngine.RaycastHit[] UnityEngine.Physics::RaycastAll(UnityEngine.Vector3,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_RaycastAll_m5103E7C60CC66BAFA6534D1736138A92EB1EF2B8 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// System.Int32 UnityEngine.PhysicsScene::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method);
// UnityEngine.RaycastHit[] UnityEngine.Physics::Query_SphereCastAll_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Vector3&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_Query_SphereCastAll_Injected_mE9FEF854EB63E9814AE2A53400ABD8A0C116A17E (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction3, float ___maxDistance4, int32_t ___mask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method);
// UnityEngine.RaycastHit[] UnityEngine.Physics::Query_SphereCastAll(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_Query_SphereCastAll_m290982F68113941617D41D76F6BA6A1691688701 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction3, float ___maxDistance4, int32_t ___mask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method);
// UnityEngine.RaycastHit[] UnityEngine.Physics::SphereCastAll(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_SphereCastAll_m819438325E419C699AE3245CB9C08B300A6CFCD9 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method);
// UnityEngine.RaycastHit[] UnityEngine.Physics::SphereCastAll(UnityEngine.Ray,System.Single,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_SphereCastAll_m33BB4ED4BCC53FDCE44B4236ABE0C452BB352C9E (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___radius1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// UnityEngine.Collider[] UnityEngine.Physics::OverlapSphere_Internal_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* Physics_OverlapSphere_Internal_Injected_mBC7164D0CB4C0ED3299EE6515F162F324C16D291 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___position1, float ___radius2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// UnityEngine.Collider[] UnityEngine.Physics::OverlapSphere_Internal(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* Physics_OverlapSphere_Internal_m92572431C76930C21D10CEFC0F0D37B945A6F4FF (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position1, float ___radius2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// UnityEngine.Collider[] UnityEngine.Physics::OverlapSphere(UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* Physics_OverlapSphere_m1CDA8916BA89EE2B497158A08CD571044D60054B (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, float ___radius1, int32_t ___layerMask2, int32_t ___queryTriggerInteraction3, const RuntimeMethod* method);
// System.Boolean UnityEngine.Physics::Query_ComputePenetration_Injected(UnityEngine.Collider,UnityEngine.Vector3&,UnityEngine.Quaternion&,UnityEngine.Collider,UnityEngine.Vector3&,UnityEngine.Quaternion&,UnityEngine.Vector3&,System.Single&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Query_ComputePenetration_Injected_mF8C23B35E141DFDE213242F410BC8B89159B22A9 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___colliderA0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___positionA1, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * ___rotationA2, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___colliderB3, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___positionB4, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * ___rotationB5, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction6, float* ___distance7, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.Vector3::get_zero()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Vector3_get_zero_m1A8F7993167785F750B6B01762D22C2597C84EF6 (const RuntimeMethod* method);
// System.Boolean UnityEngine.Physics::Query_ComputePenetration(UnityEngine.Collider,UnityEngine.Vector3,UnityEngine.Quaternion,UnityEngine.Collider,UnityEngine.Vector3,UnityEngine.Quaternion,UnityEngine.Vector3&,System.Single&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Query_ComputePenetration_m6B55B585ECB5C4EF7A699781719BC23A8638103D (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___colliderA0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___positionA1, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___rotationA2, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___colliderB3, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___positionB4, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___rotationB5, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction6, float* ___distance7, const RuntimeMethod* method);
// System.Int32 UnityEngine.PhysicsScene::OverlapSphere(UnityEngine.Vector3,System.Single,UnityEngine.Collider[],System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_OverlapSphere_mBFBB0C810534D52967EE4FDC97DB67301D769ACC (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, float ___radius1, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* ___results2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// System.Int32 UnityEngine.Physics::OverlapSphereNonAlloc(UnityEngine.Vector3,System.Single,UnityEngine.Collider[],System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_OverlapSphereNonAlloc_mD1A616CEF8B7C991A9E56B7E17FF5BCF7C4B8431 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, float ___radius1, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* ___results2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// System.Int32 UnityEngine.PhysicsScene::SphereCast(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_SphereCast_m36723F888676E712CC40A0E54D72E95F73D193D3 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results3, float ___maxDistance4, int32_t ___layerMask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method);
// System.Int32 UnityEngine.Physics::SphereCastNonAlloc(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_SphereCastNonAlloc_m9635CF65AE04223E3A6DF9E7B860D9C7B8E984E7 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results3, float ___maxDistance4, int32_t ___layerMask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method);
// System.String UnityEngine.UnityString::Format(System.String,System.Object[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UnityString_Format_m7A07C068ED408DD06F634070770FB55F13AA4EC9 (String_t* ___fmt0, ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* ___args1, const RuntimeMethod* method);
// System.String UnityEngine.PhysicsScene::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* PhysicsScene_ToString_mBB6D0AC1E3E2EDC34CB4A7A34485B24B6271903F (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, const RuntimeMethod* method);
// System.Int32 UnityEngine.PhysicsScene::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_GetHashCode_m5344CC6CCCB1CA6EBB149775EE028089DD74B8A2 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Equals_m2645ABB96C598F197F734EB712494795928CBCEC (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, RuntimeObject * ___other0, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Equals(UnityEngine.PhysicsScene)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Equals_m8C948B86D105177D519A3608816CDC698C8686B8 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___other0, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Internal_RaycastTest(UnityEngine.PhysicsScene,UnityEngine.Ray,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Internal_RaycastTest_m6715CAD8D0330195269AA7FCCD91613BC564E3EB (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Internal_RaycastTest_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Internal_RaycastTest_Injected_m956474EFEA507F82ABE0BCB75DDB3CC8EFF4D12B (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * ___ray1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Internal_Raycast(UnityEngine.PhysicsScene,UnityEngine.Ray,System.Single,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Internal_Raycast_m1E630AA11805114B090FC50741AEF64D677AF2C7 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray1, float ___maxDistance2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hit3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Internal_Raycast_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,System.Single,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Internal_Raycast_Injected_m8868E0BF89F8C42D11F42F94F9CF767647433BB1 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * ___ray1, float ___maxDistance2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hit3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.Vector3::get_normalized()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Vector3_get_normalized_m2FA6DF38F97BDA4CCBDAE12B9FE913A241DAC8D5 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * __this, const RuntimeMethod* method);
// System.Int32 UnityEngine.PhysicsScene::Internal_RaycastNonAlloc(UnityEngine.PhysicsScene,UnityEngine.Ray,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_Internal_RaycastNonAlloc_mE7833EE5F1082431A4C2D29362F5DCDEFBF6D2BD (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits2, float ___maxDistance3, int32_t ___mask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method);
// System.Int32 UnityEngine.PhysicsScene::Internal_RaycastNonAlloc_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_Internal_RaycastNonAlloc_Injected_m59FB44C18E62D21E9320F30229C0AA9F9B971211 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * ___ray1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits2, float ___maxDistance3, int32_t ___mask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Query_SphereCast_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Vector3&,System.Single,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Query_SphereCast_Injected_m6DD8E497811A3098113F5E9F52D7B0CAE63DC1EB (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction3, float ___maxDistance4, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo5, int32_t ___layerMask6, int32_t ___queryTriggerInteraction7, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Query_SphereCast(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,UnityEngine.Vector3,System.Single,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Query_SphereCast_m47352512958CE213DD034AE53DB2E0C0247A38C3 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction3, float ___maxDistance4, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo5, int32_t ___layerMask6, int32_t ___queryTriggerInteraction7, const RuntimeMethod* method);
// System.Boolean UnityEngine.PhysicsScene::Internal_SphereCast(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Internal_SphereCast_mFEE43A5306A097D0D2CB389A200921320130E55B (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction3, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo4, float ___maxDistance5, int32_t ___layerMask6, int32_t ___queryTriggerInteraction7, const RuntimeMethod* method);
// System.Int32 UnityEngine.PhysicsScene::Internal_SphereCastNonAlloc_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Vector3&,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_Internal_SphereCastNonAlloc_Injected_m4F9D87DA90995ECD2AD86314F57231722EE2C894 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction3, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits4, float ___maxDistance5, int32_t ___mask6, int32_t ___queryTriggerInteraction7, const RuntimeMethod* method);
// System.Int32 UnityEngine.PhysicsScene::Internal_SphereCastNonAlloc(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_Internal_SphereCastNonAlloc_mB8513F888165C580ED47D021D1A0832A0175098A (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction3, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits4, float ___maxDistance5, int32_t ___mask6, int32_t ___queryTriggerInteraction7, const RuntimeMethod* method);
// System.Int32 UnityEngine.PhysicsScene::OverlapSphereNonAlloc_Internal_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Collider[],System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_OverlapSphereNonAlloc_Internal_Injected_mFD0BF0E38E9E17D7AB571531EDC7F181CF4BEFB3 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___position1, float ___radius2, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* ___results3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method);
// System.Int32 UnityEngine.PhysicsScene::OverlapSphereNonAlloc_Internal(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,UnityEngine.Collider[],System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_OverlapSphereNonAlloc_Internal_m164D02A6A67B8CB8E1CAEDE56AD48CC0042435D7 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position1, float ___radius2, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* ___results3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method);
// UnityEngine.Object UnityEngine.Object::FindObjectFromInstanceID(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Object_tF2F3778131EFF286AF62B7B013A170F95A91571A * Object_FindObjectFromInstanceID_m0AD731D3F583CBBDC7DC0E08B38F742B447FA44A (int32_t ___instanceID0, const RuntimeMethod* method);
// UnityEngine.Collider UnityEngine.RaycastHit::get_collider()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.RaycastHit::get_point()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E RaycastHit_get_point_m32F7282CBB2E13393A33BAD046BDA218E48DD21E (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.RaycastHit::set_point(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RaycastHit_set_point_mBB4D9069F8DB5BA15E31DBA68AB68789687FA88F (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.RaycastHit::get_normal()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E RaycastHit_get_normal_m2C813B25BAECD87FD9E9CB294278B291F4CC6674 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.RaycastHit::set_normal(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RaycastHit_set_normal_mAD9EEA4720F62D7286E9EAE8F26753352EFF9270 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.Vector3::.ctor(System.Single,System.Single,System.Single)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void Vector3__ctor_m57495F692C6CE1CEF278CAD9A98221165D37E636_inline (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * __this, float ___x0, float ___y1, float ___z2, const RuntimeMethod* method);
// UnityEngine.Vector3 UnityEngine.RaycastHit::get_barycentricCoordinate()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E RaycastHit_get_barycentricCoordinate_mF5FE7CE94A15D9FB47C617CC62CD7C4E785F6B91 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// System.Single UnityEngine.RaycastHit::get_distance()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float RaycastHit_get_distance_m85FCA98D7957C3BF1D449CA1B48C116CCD6226FA (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.RaycastHit::set_distance(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RaycastHit_set_distance_m287DCD9DAE1D3AE76C7C4DE2F192E4DFBA911F41 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, float ___value0, const RuntimeMethod* method);
// System.Int32 UnityEngine.RaycastHit::get_triangleIndex()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t RaycastHit_get_triangleIndex_mC9FE4EB1B57D5EAFB3B116F4FD3332ADC50E5538 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.RaycastHit::CalculateRaycastTexCoord_Injected(UnityEngine.Collider,UnityEngine.Vector2&,UnityEngine.Vector3&,System.UInt32,System.Int32,UnityEngine.Vector2&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RaycastHit_CalculateRaycastTexCoord_Injected_m1FF45C3E7C9706065ED99031A70BDD8F7F8202CE (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider0, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * ___uv1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___pos2, uint32_t ___face3, int32_t ___textcoord4, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * ___ret5, const RuntimeMethod* method);
// UnityEngine.Vector2 UnityEngine.RaycastHit::CalculateRaycastTexCoord(UnityEngine.Collider,UnityEngine.Vector2,UnityEngine.Vector3,System.UInt32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_CalculateRaycastTexCoord_mA0C4A5964A2CC5EE35AD330FCF15B37D85827554 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider0, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___uv1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___pos2, uint32_t ___face3, int32_t ___textcoord4, const RuntimeMethod* method);
// UnityEngine.Vector2 UnityEngine.RaycastHit::get_textureCoord()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_get_textureCoord_m14246DFF0F641326DFE9CFDCD326F727A3EE3777 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// UnityEngine.Vector2 UnityEngine.RaycastHit::get_textureCoord2()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_get_textureCoord2_m93EA616280855F963876CD677D94AF857DAE9E57 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// UnityEngine.Rigidbody UnityEngine.RaycastHit::get_rigidbody()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * RaycastHit_get_rigidbody_mE48E45893FDAFD03162C6A73AAF02C6CB0E079FB (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// UnityEngine.Transform UnityEngine.Component::get_transform()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * Component_get_transform_mE8496EBC45BEB1BADB5F314960F1DF1C952FA11F (Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684 * __this, const RuntimeMethod* method);
// UnityEngine.Transform UnityEngine.RaycastHit::get_transform()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * RaycastHit_get_transform_m2DD983DBD3602DE848DE287EE5233FD02EEC608D (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// UnityEngine.Rigidbody UnityEngine.Collider::get_attachedRigidbody()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * Collider_get_attachedRigidbody_m101FED12AD292F372F98E94A6D02A5E428AA896A (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, const RuntimeMethod* method);
// !!0 UnityEngine.Component::GetComponent<UnityEngine.Renderer>()
inline Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C * Component_GetComponent_TisRenderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C_m436E5B0F17DDEF3CC61F77DEA82B1A92668AF019 (Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684 * __this, const RuntimeMethod* method)
{
return (( Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C * (*) (Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684 *, const RuntimeMethod*))Component_GetComponent_TisRuntimeObject_m69D9C576D6DD024C709E29EEADBC8041299A3AA7_gshared)(__this, method);
}
// UnityEngine.Vector4 UnityEngine.Renderer::get_lightmapScaleOffset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 Renderer_get_lightmapScaleOffset_mB2A11E1B4F8F34DBC7F95165AC5EAB80553E2A62 (Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C * __this, const RuntimeMethod* method);
// UnityEngine.Vector2 UnityEngine.RaycastHit::get_lightmapCoord()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_get_lightmapCoord_mAD5C7DFC562B22AC97DC2573C34C8BB364676FD9 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::get_velocity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_get_velocity_Injected_m79C6BB8C054D0B5F03F3F13325910BC068E5B796 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::set_velocity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_velocity_Injected_mBFBC7681B33942F69A5CD908941D399777F66ADD (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::get_angularVelocity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_get_angularVelocity_Injected_mD00F8790DFF2A31A033487AC67C4C018F28D0D13 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::set_angularVelocity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_angularVelocity_Injected_m5ED47D0F131F6B3788B8B736DA7854FD63C13D56 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::set_centerOfMass_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_centerOfMass_Injected_m60EC1BE2558EC9A9BD40ED144A1C848E6A4BCD9D (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::get_position_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_get_position_Injected_m16D551CF5A925BD26F4E77116483B2B36115A079 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::get_rotation_Injected(UnityEngine.Quaternion&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_get_rotation_Injected_mA9DA175CC81C9D6D4D7098C34CF5378C4C2955D8 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::set_rotation_Injected(UnityEngine.Quaternion&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_rotation_Injected_mBB08A477E5E134A4E6FFF381BFDE9E2959844EE9 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::MovePosition_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_MovePosition_Injected_m06454253A0DF550B2EAD47F545734E8735BA0732 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___position0, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::MoveRotation_Injected(UnityEngine.Quaternion&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_MoveRotation_Injected_mB730FBD0786AE2DEC454E76326E08ED79CEEF440 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * ___rot0, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::AddForce_Injected(UnityEngine.Vector3&,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddForce_Injected_m233C3E22C3FE9D2BCBBC510132B82CE26057370C (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___force0, int32_t ___mode1, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::AddForce(UnityEngine.Vector3,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddForce_m78B9D94F505E19F3C63461362AD6DE7EA0836700 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___force0, int32_t ___mode1, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::AddTorque_Injected(UnityEngine.Vector3&,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddTorque_Injected_mFFD31FDF8F82D3D740EA83348BBC0D0D5EB0DB3A (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___torque0, int32_t ___mode1, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::AddTorque(UnityEngine.Vector3,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddTorque_mEDE3483056FB07222A4D096F22D45C7D8A6E2552 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___torque0, int32_t ___mode1, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::AddForceAtPosition_Injected(UnityEngine.Vector3&,UnityEngine.Vector3&,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddForceAtPosition_Injected_m60ED364228EF475F97B0FF1D0F4EFCAB97382DDB (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___force0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___position1, int32_t ___mode2, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::AddForceAtPosition(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddForceAtPosition_mEE49C058A6D57C1D5A78207494BFED5906D80D0F (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___force0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position1, int32_t ___mode2, const RuntimeMethod* method);
// System.Void UnityEngine.Rigidbody::AddExplosionForce_Injected(System.Single,UnityEngine.Vector3&,System.Single,System.Single,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddExplosionForce_Injected_m8CCDC7FDD8F5F1BC231094105B3076815A16E22D (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, float ___explosionForce0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___explosionPosition1, float ___explosionRadius2, float ___upwardsModifier3, int32_t ___mode4, const RuntimeMethod* method);
// System.Void UnityEngine.SphereCollider::get_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SphereCollider_get_center_Injected_mF082CC62A7E8DE3DD5B86518C210D85139DD93CB (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method);
// System.Void UnityEngine.SphereCollider::set_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SphereCollider_set_center_Injected_mB213D6CB194E150BBEF8EC2AA31EA391C2F4A641 (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method);
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector3 UnityEngine.BoxCollider::get_center()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E BoxCollider_get_center_m832B93439717C72D4A3B427C6E8F5B54E2DBD669 (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
BoxCollider_get_center_Injected_m5F060E93AE651FB756B9371C7A716BDAA2A96F51(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = V_0;
return L_0;
}
}
// System.Void UnityEngine.BoxCollider::set_center(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void BoxCollider_set_center_m02D745E759A66BBEF405D33CE4ACE34B7E064178 (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
{
BoxCollider_set_center_Injected_m54F8740514B14E3B53063FB4C7623BF0F2A48F0A(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___value0), /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Vector3 UnityEngine.BoxCollider::get_size()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E BoxCollider_get_size_mBC38D4926D4BE54A6532F6E1D642F363CA3A58A1 (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
BoxCollider_get_size_Injected_mC9ABFED6FEC27351BC116B44021578CB39CBCB22(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = V_0;
return L_0;
}
}
// System.Void UnityEngine.BoxCollider::set_size(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void BoxCollider_set_size_mD9153B4AE4C366ACAB9E5F49075D919A89168B2E (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
{
BoxCollider_set_size_Injected_m7A8B807F4AB573BF955610F55AAD372FF868C967(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.BoxCollider::get_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void BoxCollider_get_center_Injected_m5F060E93AE651FB756B9371C7A716BDAA2A96F51 (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method)
{
typedef void (*BoxCollider_get_center_Injected_m5F060E93AE651FB756B9371C7A716BDAA2A96F51_ftn) (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static BoxCollider_get_center_Injected_m5F060E93AE651FB756B9371C7A716BDAA2A96F51_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (BoxCollider_get_center_Injected_m5F060E93AE651FB756B9371C7A716BDAA2A96F51_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.BoxCollider::get_center_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___ret0);
}
// System.Void UnityEngine.BoxCollider::set_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void BoxCollider_set_center_Injected_m54F8740514B14E3B53063FB4C7623BF0F2A48F0A (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method)
{
typedef void (*BoxCollider_set_center_Injected_m54F8740514B14E3B53063FB4C7623BF0F2A48F0A_ftn) (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static BoxCollider_set_center_Injected_m54F8740514B14E3B53063FB4C7623BF0F2A48F0A_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (BoxCollider_set_center_Injected_m54F8740514B14E3B53063FB4C7623BF0F2A48F0A_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.BoxCollider::set_center_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.BoxCollider::get_size_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void BoxCollider_get_size_Injected_mC9ABFED6FEC27351BC116B44021578CB39CBCB22 (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method)
{
typedef void (*BoxCollider_get_size_Injected_mC9ABFED6FEC27351BC116B44021578CB39CBCB22_ftn) (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static BoxCollider_get_size_Injected_mC9ABFED6FEC27351BC116B44021578CB39CBCB22_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (BoxCollider_get_size_Injected_mC9ABFED6FEC27351BC116B44021578CB39CBCB22_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.BoxCollider::get_size_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___ret0);
}
// System.Void UnityEngine.BoxCollider::set_size_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void BoxCollider_set_size_Injected_m7A8B807F4AB573BF955610F55AAD372FF868C967 (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method)
{
typedef void (*BoxCollider_set_size_Injected_m7A8B807F4AB573BF955610F55AAD372FF868C967_ftn) (BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static BoxCollider_set_size_Injected_m7A8B807F4AB573BF955610F55AAD372FF868C967_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (BoxCollider_set_size_Injected_m7A8B807F4AB573BF955610F55AAD372FF868C967_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.BoxCollider::set_size_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___value0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector3 UnityEngine.CapsuleCollider::get_center()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E CapsuleCollider_get_center_m6374F7457A9450CAFFAD2DF0C9D1419BF9E304CB (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
CapsuleCollider_get_center_Injected_mBDF07E6DE932FBCAF0AA6F167EB993BE03BE6872(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = V_0;
return L_0;
}
}
// System.Void UnityEngine.CapsuleCollider::set_center(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CapsuleCollider_set_center_m36F35F070DFC2CBFC87532004073CA8D56F3678F (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
{
CapsuleCollider_set_center_Injected_mB43C17AC81236FB74E61E21215D2145663A7DEEE(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Single UnityEngine.CapsuleCollider::get_radius()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float CapsuleCollider_get_radius_m5746DDE5E6A099269FC9DAD253887C58E8A064D0 (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, const RuntimeMethod* method)
{
typedef float (*CapsuleCollider_get_radius_m5746DDE5E6A099269FC9DAD253887C58E8A064D0_ftn) (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 *);
static CapsuleCollider_get_radius_m5746DDE5E6A099269FC9DAD253887C58E8A064D0_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CapsuleCollider_get_radius_m5746DDE5E6A099269FC9DAD253887C58E8A064D0_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CapsuleCollider::get_radius()");
float icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.CapsuleCollider::set_radius(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CapsuleCollider_set_radius_mD4502A8676AAC093F1E9958FB7D5D765EA206432 (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, float ___value0, const RuntimeMethod* method)
{
typedef void (*CapsuleCollider_set_radius_mD4502A8676AAC093F1E9958FB7D5D765EA206432_ftn) (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 *, float);
static CapsuleCollider_set_radius_mD4502A8676AAC093F1E9958FB7D5D765EA206432_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CapsuleCollider_set_radius_mD4502A8676AAC093F1E9958FB7D5D765EA206432_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CapsuleCollider::set_radius(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Single UnityEngine.CapsuleCollider::get_height()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float CapsuleCollider_get_height_mD6CF93CB2C222F8E5B77D65B0356F8FD8005B526 (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, const RuntimeMethod* method)
{
typedef float (*CapsuleCollider_get_height_mD6CF93CB2C222F8E5B77D65B0356F8FD8005B526_ftn) (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 *);
static CapsuleCollider_get_height_mD6CF93CB2C222F8E5B77D65B0356F8FD8005B526_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CapsuleCollider_get_height_mD6CF93CB2C222F8E5B77D65B0356F8FD8005B526_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CapsuleCollider::get_height()");
float icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.CapsuleCollider::set_height(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CapsuleCollider_set_height_m728C9AF3772EEC1DA9845E19F3C2899CDD2D9496 (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, float ___value0, const RuntimeMethod* method)
{
typedef void (*CapsuleCollider_set_height_m728C9AF3772EEC1DA9845E19F3C2899CDD2D9496_ftn) (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 *, float);
static CapsuleCollider_set_height_m728C9AF3772EEC1DA9845E19F3C2899CDD2D9496_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CapsuleCollider_set_height_m728C9AF3772EEC1DA9845E19F3C2899CDD2D9496_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CapsuleCollider::set_height(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Int32 UnityEngine.CapsuleCollider::get_direction()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t CapsuleCollider_get_direction_m2C5110BBCA2CC1C63183CDBD73B6D11CC89B0918 (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, const RuntimeMethod* method)
{
typedef int32_t (*CapsuleCollider_get_direction_m2C5110BBCA2CC1C63183CDBD73B6D11CC89B0918_ftn) (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 *);
static CapsuleCollider_get_direction_m2C5110BBCA2CC1C63183CDBD73B6D11CC89B0918_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CapsuleCollider_get_direction_m2C5110BBCA2CC1C63183CDBD73B6D11CC89B0918_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CapsuleCollider::get_direction()");
int32_t icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.CapsuleCollider::get_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CapsuleCollider_get_center_Injected_mBDF07E6DE932FBCAF0AA6F167EB993BE03BE6872 (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method)
{
typedef void (*CapsuleCollider_get_center_Injected_mBDF07E6DE932FBCAF0AA6F167EB993BE03BE6872_ftn) (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static CapsuleCollider_get_center_Injected_mBDF07E6DE932FBCAF0AA6F167EB993BE03BE6872_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CapsuleCollider_get_center_Injected_mBDF07E6DE932FBCAF0AA6F167EB993BE03BE6872_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CapsuleCollider::get_center_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___ret0);
}
// System.Void UnityEngine.CapsuleCollider::set_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CapsuleCollider_set_center_Injected_mB43C17AC81236FB74E61E21215D2145663A7DEEE (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method)
{
typedef void (*CapsuleCollider_set_center_Injected_mB43C17AC81236FB74E61E21215D2145663A7DEEE_ftn) (CapsuleCollider_t89745329298279F4827FE29C54CC2F8A28654635 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static CapsuleCollider_set_center_Injected_mB43C17AC81236FB74E61E21215D2145663A7DEEE_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CapsuleCollider_set_center_Injected_mB43C17AC81236FB74E61E21215D2145663A7DEEE_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CapsuleCollider::set_center_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___value0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.CollisionFlags UnityEngine.CharacterController::Move(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t CharacterController_Move_mE0EBC32C72A0BEC18EDEBE748D44309A4BA32E60 (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___motion0, const RuntimeMethod* method)
{
{
int32_t L_0;
L_0 = CharacterController_Move_Injected_m6A2168A4CDC70CB62E4A4DCB15A74133E8C6C46D(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___motion0), /*hidden argument*/NULL);
return L_0;
}
}
// UnityEngine.Vector3 UnityEngine.CharacterController::get_velocity()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E CharacterController_get_velocity_m13A2C2D13A171D9A6E899C0E472C68FCF5E3D5A6 (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
CharacterController_get_velocity_Injected_mBECC6B79E09E2530E7CFADB71232589CD15C2A9E(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = V_0;
return L_0;
}
}
// System.Boolean UnityEngine.CharacterController::get_isGrounded()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool CharacterController_get_isGrounded_m327A1A1940F225FE81E751F255316BB0D8698CBC (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * __this, const RuntimeMethod* method)
{
typedef bool (*CharacterController_get_isGrounded_m327A1A1940F225FE81E751F255316BB0D8698CBC_ftn) (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E *);
static CharacterController_get_isGrounded_m327A1A1940F225FE81E751F255316BB0D8698CBC_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CharacterController_get_isGrounded_m327A1A1940F225FE81E751F255316BB0D8698CBC_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CharacterController::get_isGrounded()");
bool icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Single UnityEngine.CharacterController::get_radius()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float CharacterController_get_radius_m2262E37FB4E2F7C5E2CA7FF95754B31C962C4AF0 (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * __this, const RuntimeMethod* method)
{
typedef float (*CharacterController_get_radius_m2262E37FB4E2F7C5E2CA7FF95754B31C962C4AF0_ftn) (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E *);
static CharacterController_get_radius_m2262E37FB4E2F7C5E2CA7FF95754B31C962C4AF0_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CharacterController_get_radius_m2262E37FB4E2F7C5E2CA7FF95754B31C962C4AF0_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CharacterController::get_radius()");
float icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Single UnityEngine.CharacterController::get_height()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float CharacterController_get_height_m0F5572DEDEB689040DC280636D7F8D4C258662F6 (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * __this, const RuntimeMethod* method)
{
typedef float (*CharacterController_get_height_m0F5572DEDEB689040DC280636D7F8D4C258662F6_ftn) (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E *);
static CharacterController_get_height_m0F5572DEDEB689040DC280636D7F8D4C258662F6_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CharacterController_get_height_m0F5572DEDEB689040DC280636D7F8D4C258662F6_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CharacterController::get_height()");
float icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// UnityEngine.CollisionFlags UnityEngine.CharacterController::Move_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t CharacterController_Move_Injected_m6A2168A4CDC70CB62E4A4DCB15A74133E8C6C46D (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___motion0, const RuntimeMethod* method)
{
typedef int32_t (*CharacterController_Move_Injected_m6A2168A4CDC70CB62E4A4DCB15A74133E8C6C46D_ftn) (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static CharacterController_Move_Injected_m6A2168A4CDC70CB62E4A4DCB15A74133E8C6C46D_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CharacterController_Move_Injected_m6A2168A4CDC70CB62E4A4DCB15A74133E8C6C46D_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CharacterController::Move_Injected(UnityEngine.Vector3&)");
int32_t icallRetVal = _il2cpp_icall_func(__this, ___motion0);
return icallRetVal;
}
// System.Void UnityEngine.CharacterController::get_velocity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CharacterController_get_velocity_Injected_mBECC6B79E09E2530E7CFADB71232589CD15C2A9E (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method)
{
typedef void (*CharacterController_get_velocity_Injected_mBECC6B79E09E2530E7CFADB71232589CD15C2A9E_ftn) (CharacterController_tCCF68621C784CCB3391E0C66FE134F6F93DD6C2E *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static CharacterController_get_velocity_Injected_mBECC6B79E09E2530E7CFADB71232589CD15C2A9E_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (CharacterController_get_velocity_Injected_mBECC6B79E09E2530E7CFADB71232589CD15C2A9E_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.CharacterController::get_velocity_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___ret0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Boolean UnityEngine.Collider::get_enabled()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Collider_get_enabled_m03B73B5C97033F939387D1785BDF2619CADAEEB0 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, const RuntimeMethod* method)
{
typedef bool (*Collider_get_enabled_m03B73B5C97033F939387D1785BDF2619CADAEEB0_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *);
static Collider_get_enabled_m03B73B5C97033F939387D1785BDF2619CADAEEB0_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Collider_get_enabled_m03B73B5C97033F939387D1785BDF2619CADAEEB0_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Collider::get_enabled()");
bool icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.Collider::set_enabled(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Collider_set_enabled_m047B4D830755CD36671F7A60BFAA9C0D61F6C4A1 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, bool ___value0, const RuntimeMethod* method)
{
typedef void (*Collider_set_enabled_m047B4D830755CD36671F7A60BFAA9C0D61F6C4A1_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, bool);
static Collider_set_enabled_m047B4D830755CD36671F7A60BFAA9C0D61F6C4A1_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Collider_set_enabled_m047B4D830755CD36671F7A60BFAA9C0D61F6C4A1_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Collider::set_enabled(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Rigidbody UnityEngine.Collider::get_attachedRigidbody()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * Collider_get_attachedRigidbody_m101FED12AD292F372F98E94A6D02A5E428AA896A (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, const RuntimeMethod* method)
{
typedef Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * (*Collider_get_attachedRigidbody_m101FED12AD292F372F98E94A6D02A5E428AA896A_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *);
static Collider_get_attachedRigidbody_m101FED12AD292F372F98E94A6D02A5E428AA896A_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Collider_get_attachedRigidbody_m101FED12AD292F372F98E94A6D02A5E428AA896A_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Collider::get_attachedRigidbody()");
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Boolean UnityEngine.Collider::get_isTrigger()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Collider_get_isTrigger_m3A9C990365C94B7125DB5993D782D3D0FE876A60 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, const RuntimeMethod* method)
{
typedef bool (*Collider_get_isTrigger_m3A9C990365C94B7125DB5993D782D3D0FE876A60_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *);
static Collider_get_isTrigger_m3A9C990365C94B7125DB5993D782D3D0FE876A60_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Collider_get_isTrigger_m3A9C990365C94B7125DB5993D782D3D0FE876A60_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Collider::get_isTrigger()");
bool icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.Collider::set_isTrigger(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Collider_set_isTrigger_mEDFE3DFA29D42E9DEB9D91A3D25BACC4470305ED (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, bool ___value0, const RuntimeMethod* method)
{
typedef void (*Collider_set_isTrigger_mEDFE3DFA29D42E9DEB9D91A3D25BACC4470305ED_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, bool);
static Collider_set_isTrigger_mEDFE3DFA29D42E9DEB9D91A3D25BACC4470305ED_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Collider_set_isTrigger_mEDFE3DFA29D42E9DEB9D91A3D25BACC4470305ED_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Collider::set_isTrigger(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Vector3 UnityEngine.Collider::ClosestPoint(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Collider_ClosestPoint_m7777917E298B31796DEE906B54F0102F6ED76676 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Collider_ClosestPoint_Injected_m6D72FF73D51838EE47234CB4D6234521C08B780D(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___position0), (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = V_0;
return L_0;
}
}
// UnityEngine.Bounds UnityEngine.Collider::get_bounds()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 Collider_get_bounds_mE341D29E1DA184ADD53A474D57D9082A3550EACB (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, const RuntimeMethod* method)
{
Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 V_0;
memset((&V_0), 0, sizeof(V_0));
{
Collider_get_bounds_Injected_m9BA8C3BC133BC241D571849C4F10F67A951CA962(__this, (Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 *)(&V_0), /*hidden argument*/NULL);
Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 L_0 = V_0;
return L_0;
}
}
// System.Void UnityEngine.Collider::set_material(UnityEngine.PhysicMaterial)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Collider_set_material_m3B07EBDE2756F6F250C6202EA1F67C95072B9D72 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, PhysicMaterial_tD3D9C84806E95BABF076A74331DF8D9A4B03E3C2 * ___value0, const RuntimeMethod* method)
{
typedef void (*Collider_set_material_m3B07EBDE2756F6F250C6202EA1F67C95072B9D72_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, PhysicMaterial_tD3D9C84806E95BABF076A74331DF8D9A4B03E3C2 *);
static Collider_set_material_m3B07EBDE2756F6F250C6202EA1F67C95072B9D72_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Collider_set_material_m3B07EBDE2756F6F250C6202EA1F67C95072B9D72_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Collider::set_material(UnityEngine.PhysicMaterial)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.RaycastHit UnityEngine.Collider::Raycast(UnityEngine.Ray,System.Single,System.Boolean&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 Collider_Raycast_mEB5EDB2C67ABBA9929AE8A898660641E8C82E609 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___maxDistance1, bool* ___hasHit2, const RuntimeMethod* method)
{
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 V_0;
memset((&V_0), 0, sizeof(V_0));
{
float L_0 = ___maxDistance1;
bool* L_1 = ___hasHit2;
Collider_Raycast_Injected_m7176D9E8617D67331E20F519855B8708C63B9E9E(__this, (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), L_0, (bool*)L_1, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)(&V_0), /*hidden argument*/NULL);
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 L_2 = V_0;
return L_2;
}
}
// System.Boolean UnityEngine.Collider::Raycast(UnityEngine.Ray,UnityEngine.RaycastHit&,System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Collider_Raycast_m41CA5C3C07B92F5325CB81890BE3A611C3C70784 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo1, float ___maxDistance2, const RuntimeMethod* method)
{
bool V_0 = false;
bool V_1 = false;
{
V_0 = (bool)0;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_0 = ___hitInfo1;
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 L_1 = ___ray0;
float L_2 = ___maxDistance2;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 L_3;
L_3 = Collider_Raycast_mEB5EDB2C67ABBA9929AE8A898660641E8C82E609(__this, L_1, L_2, (bool*)(&V_0), /*hidden argument*/NULL);
*(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_0 = L_3;
bool L_4 = V_0;
V_1 = L_4;
goto IL_0017;
}
IL_0017:
{
bool L_5 = V_1;
return L_5;
}
}
// System.Void UnityEngine.Collider::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Collider__ctor_m09D7A9B985D74FD50346DA08D88EB1874E968B69 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, const RuntimeMethod* method)
{
{
Component__ctor_m0B00FA207EB3E560B78938D8AD877DB2BC1E3722(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Collider::ClosestPoint_Injected(UnityEngine.Vector3&,UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Collider_ClosestPoint_Injected_m6D72FF73D51838EE47234CB4D6234521C08B780D (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___position0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret1, const RuntimeMethod* method)
{
typedef void (*Collider_ClosestPoint_Injected_m6D72FF73D51838EE47234CB4D6234521C08B780D_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static Collider_ClosestPoint_Injected_m6D72FF73D51838EE47234CB4D6234521C08B780D_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Collider_ClosestPoint_Injected_m6D72FF73D51838EE47234CB4D6234521C08B780D_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Collider::ClosestPoint_Injected(UnityEngine.Vector3&,UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___position0, ___ret1);
}
// System.Void UnityEngine.Collider::get_bounds_Injected(UnityEngine.Bounds&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Collider_get_bounds_Injected_m9BA8C3BC133BC241D571849C4F10F67A951CA962 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 * ___ret0, const RuntimeMethod* method)
{
typedef void (*Collider_get_bounds_Injected_m9BA8C3BC133BC241D571849C4F10F67A951CA962_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 *);
static Collider_get_bounds_Injected_m9BA8C3BC133BC241D571849C4F10F67A951CA962_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Collider_get_bounds_Injected_m9BA8C3BC133BC241D571849C4F10F67A951CA962_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Collider::get_bounds_Injected(UnityEngine.Bounds&)");
_il2cpp_icall_func(__this, ___ret0);
}
// System.Void UnityEngine.Collider::Raycast_Injected(UnityEngine.Ray&,System.Single,System.Boolean&,UnityEngine.RaycastHit&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Collider_Raycast_Injected_m7176D9E8617D67331E20F519855B8708C63B9E9E (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * ___ray0, float ___maxDistance1, bool* ___hasHit2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___ret3, const RuntimeMethod* method)
{
typedef void (*Collider_Raycast_Injected_m7176D9E8617D67331E20F519855B8708C63B9E9E_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *, float, bool*, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *);
static Collider_Raycast_Injected_m7176D9E8617D67331E20F519855B8708C63B9E9E_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Collider_Raycast_Injected_m7176D9E8617D67331E20F519855B8708C63B9E9E_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Collider::Raycast_Injected(UnityEngine.Ray&,System.Single,System.Boolean&,UnityEngine.RaycastHit&)");
_il2cpp_icall_func(__this, ___ray0, ___maxDistance1, ___hasHit2, ___ret3);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Conversion methods for marshalling of: UnityEngine.Collision
IL2CPP_EXTERN_C void Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshal_pinvoke(const Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0& unmarshaled, Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshaled_pinvoke& marshaled)
{
Exception_t* ___m_Rigidbody_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Rigidbody' of type 'Collision': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Rigidbody_2Exception, NULL);
}
IL2CPP_EXTERN_C void Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshal_pinvoke_back(const Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshaled_pinvoke& marshaled, Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0& unmarshaled)
{
Exception_t* ___m_Rigidbody_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Rigidbody' of type 'Collision': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Rigidbody_2Exception, NULL);
}
// Conversion method for clean up from marshalling of: UnityEngine.Collision
IL2CPP_EXTERN_C void Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshal_pinvoke_cleanup(Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.Collision
IL2CPP_EXTERN_C void Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshal_com(const Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0& unmarshaled, Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshaled_com& marshaled)
{
Exception_t* ___m_Rigidbody_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Rigidbody' of type 'Collision': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Rigidbody_2Exception, NULL);
}
IL2CPP_EXTERN_C void Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshal_com_back(const Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshaled_com& marshaled, Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0& unmarshaled)
{
Exception_t* ___m_Rigidbody_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Rigidbody' of type 'Collision': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Rigidbody_2Exception, NULL);
}
// Conversion method for clean up from marshalling of: UnityEngine.Collision
IL2CPP_EXTERN_C void Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshal_com_cleanup(Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0_marshaled_com& marshaled)
{
}
// UnityEngine.Vector3 UnityEngine.Collision::get_relativeVelocity()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Collision_get_relativeVelocity_m0B0F8FA1AFAF7AB3B76083932D63A3FC1FA22442 (Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0 * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = __this->get_m_RelativeVelocity_1();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = V_0;
return L_1;
}
}
// UnityEngine.Rigidbody UnityEngine.Collision::get_rigidbody()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * Collision_get_rigidbody_m5CBE72072423B624F09E804ED99301E500D909D1 (Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0 * __this, const RuntimeMethod* method)
{
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * V_0 = NULL;
{
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * L_0 = __this->get_m_Rigidbody_2();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * L_1 = V_0;
return L_1;
}
}
// UnityEngine.Collider UnityEngine.Collision::get_collider()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * Collision_get_collider_m0AC4446E6B9168A0FB19DA376559C812E43779F8 (Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0 * __this, const RuntimeMethod* method)
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * V_0 = NULL;
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_0 = __this->get_m_Collider_3();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_1 = V_0;
return L_1;
}
}
// UnityEngine.GameObject UnityEngine.Collision::get_gameObject()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * Collision_get_gameObject_m5682F872FD28419AA36F0651CE8B19825A21859D (Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * V_0 = NULL;
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * G_B3_0 = NULL;
{
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * L_0 = __this->get_m_Rigidbody_2();
IL2CPP_RUNTIME_CLASS_INIT(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
bool L_1;
L_1 = Object_op_Inequality_mE1F187520BD83FB7D86A6D850710C4D42B864E90(L_0, (Object_tF2F3778131EFF286AF62B7B013A170F95A91571A *)NULL, /*hidden argument*/NULL);
if (L_1)
{
goto IL_001c;
}
}
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_2 = __this->get_m_Collider_3();
NullCheck(L_2);
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * L_3;
L_3 = Component_get_gameObject_m55DC35B149AFB9157582755383BA954655FE0C5B(L_2, /*hidden argument*/NULL);
G_B3_0 = L_3;
goto IL_0027;
}
IL_001c:
{
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * L_4 = __this->get_m_Rigidbody_2();
NullCheck(L_4);
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * L_5;
L_5 = Component_get_gameObject_m55DC35B149AFB9157582755383BA954655FE0C5B(L_4, /*hidden argument*/NULL);
G_B3_0 = L_5;
}
IL_0027:
{
V_0 = G_B3_0;
goto IL_002a;
}
IL_002a:
{
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * L_6 = V_0;
return L_6;
}
}
// UnityEngine.ContactPoint[] UnityEngine.Collision::get_contacts()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* Collision_get_contacts_m8C3D39F3332DD2AC623A9FB5F2127CE2754AF54B (Collision_tDC11F9B3834FD25DEB8C7DD1C51B635D240BBBF0 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* V_1 = NULL;
{
ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* L_0 = __this->get_m_LegacyContacts_6();
V_0 = (bool)((((RuntimeObject*)(ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B*)L_0) == ((RuntimeObject*)(RuntimeObject *)NULL))? 1 : 0);
bool L_1 = V_0;
if (!L_1)
{
goto IL_0039;
}
}
{
int32_t L_2 = __this->get_m_ContactCount_4();
ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* L_3 = (ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B*)(ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B*)SZArrayNew(ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B_il2cpp_TypeInfo_var, (uint32_t)L_2);
__this->set_m_LegacyContacts_6(L_3);
ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* L_4 = __this->get_m_ReusedContacts_5();
ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* L_5 = __this->get_m_LegacyContacts_6();
int32_t L_6 = __this->get_m_ContactCount_4();
Array_Copy_m40103AA97DC582C557B912CF4BBE86A4D166F803((RuntimeArray *)(RuntimeArray *)L_4, (RuntimeArray *)(RuntimeArray *)L_5, L_6, /*hidden argument*/NULL);
}
IL_0039:
{
ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* L_7 = __this->get_m_LegacyContacts_6();
V_1 = L_7;
goto IL_0042;
}
IL_0042:
{
ContactPointU5BU5D_t1ACD262B1EA44CD48E2039381DE96847F203E62B* L_8 = V_1;
return L_8;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector3 UnityEngine.ContactPoint::get_point()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ContactPoint_get_point_mEA976D5E3BC57FAB78F68BE0AA17A97293AEA5BC (ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = __this->get_m_Point_0();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = V_0;
return L_1;
}
}
IL2CPP_EXTERN_C Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ContactPoint_get_point_mEA976D5E3BC57FAB78F68BE0AA17A97293AEA5BC_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * _thisAdjusted = reinterpret_cast<ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 *>(__this + _offset);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E _returnValue;
_returnValue = ContactPoint_get_point_mEA976D5E3BC57FAB78F68BE0AA17A97293AEA5BC(_thisAdjusted, method);
return _returnValue;
}
// UnityEngine.Vector3 UnityEngine.ContactPoint::get_normal()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ContactPoint_get_normal_m0561937E45F5356C7BB90D861422BD76B36D037A (ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = __this->get_m_Normal_1();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = V_0;
return L_1;
}
}
IL2CPP_EXTERN_C Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ContactPoint_get_normal_m0561937E45F5356C7BB90D861422BD76B36D037A_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 * _thisAdjusted = reinterpret_cast<ContactPoint_tC179732A8E0014F5EFF5977ED1ADF12CF14A9017 *>(__this + _offset);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E _returnValue;
_returnValue = ContactPoint_get_normal_m0561937E45F5356C7BB90D861422BD76B36D037A(_thisAdjusted, method);
return _returnValue;
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Conversion methods for marshalling of: UnityEngine.ControllerColliderHit
IL2CPP_EXTERN_C void ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshal_pinvoke(const ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550& unmarshaled, ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshaled_pinvoke& marshaled)
{
Exception_t* ___m_Controller_0Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Controller' of type 'ControllerColliderHit': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Controller_0Exception, NULL);
}
IL2CPP_EXTERN_C void ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshal_pinvoke_back(const ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshaled_pinvoke& marshaled, ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550& unmarshaled)
{
Exception_t* ___m_Controller_0Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Controller' of type 'ControllerColliderHit': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Controller_0Exception, NULL);
}
// Conversion method for clean up from marshalling of: UnityEngine.ControllerColliderHit
IL2CPP_EXTERN_C void ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshal_pinvoke_cleanup(ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.ControllerColliderHit
IL2CPP_EXTERN_C void ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshal_com(const ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550& unmarshaled, ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshaled_com& marshaled)
{
Exception_t* ___m_Controller_0Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Controller' of type 'ControllerColliderHit': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Controller_0Exception, NULL);
}
IL2CPP_EXTERN_C void ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshal_com_back(const ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshaled_com& marshaled, ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550& unmarshaled)
{
Exception_t* ___m_Controller_0Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Controller' of type 'ControllerColliderHit': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Controller_0Exception, NULL);
}
// Conversion method for clean up from marshalling of: UnityEngine.ControllerColliderHit
IL2CPP_EXTERN_C void ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshal_com_cleanup(ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550_marshaled_com& marshaled)
{
}
// UnityEngine.Collider UnityEngine.ControllerColliderHit::get_collider()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ControllerColliderHit_get_collider_mD522F9B1F215BD1E803FF75A2FC66C03E5D7554E (ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550 * __this, const RuntimeMethod* method)
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * V_0 = NULL;
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_0 = __this->get_m_Collider_1();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_1 = V_0;
return L_1;
}
}
// UnityEngine.Vector3 UnityEngine.ControllerColliderHit::get_point()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ControllerColliderHit_get_point_m9625350F7F377C2BC98AD0FA6699F44226B3F60D (ControllerColliderHit_t483E787AA2D92263EC1F899BCF1FFC3F2B96D550 * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = __this->get_m_Point_2();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = V_0;
return L_1;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Rigidbody UnityEngine.Joint::get_connectedBody()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * Joint_get_connectedBody_m35ED1900CACED65F78E5D612BE8979142CBA68A5 (Joint_t085126F36196FC982700F4EA8466CF10C90EC15E * __this, const RuntimeMethod* method)
{
typedef Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * (*Joint_get_connectedBody_m35ED1900CACED65F78E5D612BE8979142CBA68A5_ftn) (Joint_t085126F36196FC982700F4EA8466CF10C90EC15E *);
static Joint_get_connectedBody_m35ED1900CACED65F78E5D612BE8979142CBA68A5_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Joint_get_connectedBody_m35ED1900CACED65F78E5D612BE8979142CBA68A5_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Joint::get_connectedBody()");
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.Joint::set_connectedBody(UnityEngine.Rigidbody)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Joint_set_connectedBody_m572C6C32E2FC5263AECDC460D50E5B0F79727B30 (Joint_t085126F36196FC982700F4EA8466CF10C90EC15E * __this, Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * ___value0, const RuntimeMethod* method)
{
typedef void (*Joint_set_connectedBody_m572C6C32E2FC5263AECDC460D50E5B0F79727B30_ftn) (Joint_t085126F36196FC982700F4EA8466CF10C90EC15E *, Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *);
static Joint_set_connectedBody_m572C6C32E2FC5263AECDC460D50E5B0F79727B30_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Joint_set_connectedBody_m572C6C32E2FC5263AECDC460D50E5B0F79727B30_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Joint::set_connectedBody(UnityEngine.Rigidbody)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Joint::set_anchor(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Joint_set_anchor_m3A05D61F5EF40CDAE51C6C32FC42533BA049BA47 (Joint_t085126F36196FC982700F4EA8466CF10C90EC15E * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
{
Joint_set_anchor_Injected_m036040DCC96FC83B2711CD3A9423AE91DD0C1306(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Joint::set_anchor_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Joint_set_anchor_Injected_m036040DCC96FC83B2711CD3A9423AE91DD0C1306 (Joint_t085126F36196FC982700F4EA8466CF10C90EC15E * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method)
{
typedef void (*Joint_set_anchor_Injected_m036040DCC96FC83B2711CD3A9423AE91DD0C1306_ftn) (Joint_t085126F36196FC982700F4EA8466CF10C90EC15E *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static Joint_set_anchor_Injected_m036040DCC96FC83B2711CD3A9423AE91DD0C1306_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Joint_set_anchor_Injected_m036040DCC96FC83B2711CD3A9423AE91DD0C1306_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Joint::set_anchor_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___value0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Mesh UnityEngine.MeshCollider::get_sharedMesh()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 * MeshCollider_get_sharedMesh_m77D27894F87619BD2AF868BC1156583EEC0D8CB4 (MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * __this, const RuntimeMethod* method)
{
typedef Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 * (*MeshCollider_get_sharedMesh_m77D27894F87619BD2AF868BC1156583EEC0D8CB4_ftn) (MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 *);
static MeshCollider_get_sharedMesh_m77D27894F87619BD2AF868BC1156583EEC0D8CB4_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MeshCollider_get_sharedMesh_m77D27894F87619BD2AF868BC1156583EEC0D8CB4_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MeshCollider::get_sharedMesh()");
Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 * icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.MeshCollider::set_sharedMesh(UnityEngine.Mesh)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void MeshCollider_set_sharedMesh_m5E39BE3C85A9D21D846E8B7DBA1ED14820ED0406 (MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * __this, Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 * ___value0, const RuntimeMethod* method)
{
typedef void (*MeshCollider_set_sharedMesh_m5E39BE3C85A9D21D846E8B7DBA1ED14820ED0406_ftn) (MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 *, Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 *);
static MeshCollider_set_sharedMesh_m5E39BE3C85A9D21D846E8B7DBA1ED14820ED0406_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MeshCollider_set_sharedMesh_m5E39BE3C85A9D21D846E8B7DBA1ED14820ED0406_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MeshCollider::set_sharedMesh(UnityEngine.Mesh)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Boolean UnityEngine.MeshCollider::get_convex()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool MeshCollider_get_convex_m115EB1C243F7EFD1EBAB80350E98EB3DE1A4C44C (MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * __this, const RuntimeMethod* method)
{
typedef bool (*MeshCollider_get_convex_m115EB1C243F7EFD1EBAB80350E98EB3DE1A4C44C_ftn) (MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 *);
static MeshCollider_get_convex_m115EB1C243F7EFD1EBAB80350E98EB3DE1A4C44C_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MeshCollider_get_convex_m115EB1C243F7EFD1EBAB80350E98EB3DE1A4C44C_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MeshCollider::get_convex()");
bool icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.MeshCollider::set_convex(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void MeshCollider_set_convex_mE94F2BE7760587C1944992B7AF9959ED425F631A (MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * __this, bool ___value0, const RuntimeMethod* method)
{
typedef void (*MeshCollider_set_convex_mE94F2BE7760587C1944992B7AF9959ED425F631A_ftn) (MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 *, bool);
static MeshCollider_set_convex_mE94F2BE7760587C1944992B7AF9959ED425F631A_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MeshCollider_set_convex_mE94F2BE7760587C1944992B7AF9959ED425F631A_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MeshCollider::set_convex(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector3 UnityEngine.Physics::get_gravity()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Physics_get_gravity_m58D5D94276B1E7A04E9F7108EEAAB7AB786BA532 (const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Physics_get_gravity_Injected_mC0C1A2C9C0490972A162C313425CFC05BDE6C892((Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = V_0;
return L_0;
}
}
// UnityEngine.PhysicsScene UnityEngine.Physics::get_defaultPhysicsScene()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010 (const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
{
Physics_get_defaultPhysicsScene_Injected_m0B71068269B3C8499A258BBCAEA7E3D9D020BADA((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), /*hidden argument*/NULL);
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0 = V_0;
return L_0;
}
}
// System.Void UnityEngine.Physics::IgnoreCollision(UnityEngine.Collider,UnityEngine.Collider,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Physics_IgnoreCollision_m0C99CADD1F937D967C23803147B9C22D6EC428E9 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider10, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider21, bool ___ignore2, const RuntimeMethod* method)
{
typedef void (*Physics_IgnoreCollision_m0C99CADD1F937D967C23803147B9C22D6EC428E9_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, bool);
static Physics_IgnoreCollision_m0C99CADD1F937D967C23803147B9C22D6EC428E9_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics_IgnoreCollision_m0C99CADD1F937D967C23803147B9C22D6EC428E9_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics::IgnoreCollision(UnityEngine.Collider,UnityEngine.Collider,System.Boolean)");
_il2cpp_icall_func(___collider10, ___collider21, ___ignore2);
}
// System.Void UnityEngine.Physics::IgnoreCollision(UnityEngine.Collider,UnityEngine.Collider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Physics_IgnoreCollision_m01DD85C25315CD921CE6A8BD42B694E534550610 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider10, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider21, const RuntimeMethod* method)
{
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_0 = ___collider10;
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_1 = ___collider21;
Physics_IgnoreCollision_m0C99CADD1F937D967C23803147B9C22D6EC428E9(L_0, L_1, (bool)1, /*hidden argument*/NULL);
return;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_m9DE0EEA1CF8DEF7D06216225F19E2958D341F7BA (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
float L_3 = ___maxDistance2;
int32_t L_4 = ___layerMask3;
int32_t L_5 = ___queryTriggerInteraction4;
bool L_6;
L_6 = PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
V_1 = L_6;
goto IL_0017;
}
IL_0017:
{
bool L_7 = V_1;
return L_7;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,System.Single,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_m09F21E13465121A73F19C07FC5F5314CF15ACD15 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, float ___maxDistance2, int32_t ___layerMask3, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
float L_3 = ___maxDistance2;
int32_t L_4 = ___layerMask3;
bool L_5;
L_5 = PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, 0, /*hidden argument*/NULL);
V_1 = L_5;
goto IL_0016;
}
IL_0016:
{
bool L_6 = V_1;
return L_6;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_m284670765E1627E43B7B0F5EC811A688EE595091 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, float ___maxDistance2, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
float L_3 = ___maxDistance2;
bool L_4;
L_4 = PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_4;
goto IL_0017;
}
IL_0017:
{
bool L_5 = V_1;
return L_5;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Vector3,UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_mDA2EB8C7692308A7178222D31CBA4C7A1C7DC915 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
bool L_3;
L_3 = PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, (std::numeric_limits<float>::infinity()), ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_3;
goto IL_001b;
}
IL_001b:
{
bool L_4 = V_1;
return L_4;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_m2EA572B4613E1BD7DBAA299511CFD2DBA179A163 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_3 = ___hitInfo2;
float L_4 = ___maxDistance3;
int32_t L_5 = ___layerMask4;
int32_t L_6 = ___queryTriggerInteraction5;
bool L_7;
L_7 = PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_3, L_4, L_5, L_6, /*hidden argument*/NULL);
V_1 = L_7;
goto IL_0019;
}
IL_0019:
{
bool L_8 = V_1;
return L_8;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_mCBD5F7D498C246713EDDBB446E97205DA206C49C (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, float ___maxDistance3, int32_t ___layerMask4, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_3 = ___hitInfo2;
float L_4 = ___maxDistance3;
int32_t L_5 = ___layerMask4;
bool L_6;
L_6 = PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_3, L_4, L_5, 0, /*hidden argument*/NULL);
V_1 = L_6;
goto IL_0018;
}
IL_0018:
{
bool L_7 = V_1;
return L_7;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_m18E12C65F127D1AA50D196623F04F81CB138FD12 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, float ___maxDistance3, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_3 = ___hitInfo2;
float L_4 = ___maxDistance3;
bool L_5;
L_5 = PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_3, L_4, ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_5;
goto IL_0018;
}
IL_0018:
{
bool L_6 = V_1;
return L_6;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_mE84D30EEFE59DA28DA172342068F092A35B2BE4A (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_3 = ___hitInfo2;
bool L_4;
L_4 = PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_3, (std::numeric_limits<float>::infinity()), ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_4;
goto IL_001c;
}
IL_001c:
{
bool L_5 = V_1;
return L_5;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Ray,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_m77560CCAA49DC821E51FDDD1570B921D7704646F (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___maxDistance1, int32_t ___layerMask2, int32_t ___queryTriggerInteraction3, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
float L_3 = ___maxDistance1;
int32_t L_4 = ___layerMask2;
int32_t L_5 = ___queryTriggerInteraction3;
bool L_6;
L_6 = PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
V_1 = L_6;
goto IL_0022;
}
IL_0022:
{
bool L_7 = V_1;
return L_7;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Ray,System.Single,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_mFDC4B8E7979495E3C22D0E3CEA4BCAB271EEC25A (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___maxDistance1, int32_t ___layerMask2, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
float L_3 = ___maxDistance1;
int32_t L_4 = ___layerMask2;
bool L_5;
L_5 = PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, 0, /*hidden argument*/NULL);
V_1 = L_5;
goto IL_0022;
}
IL_0022:
{
bool L_6 = V_1;
return L_6;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Ray,System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_mD7A711D3A790AC505F7229A4FFFA2E389008176B (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___maxDistance1, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
float L_3 = ___maxDistance1;
bool L_4;
L_4 = PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_4;
goto IL_0023;
}
IL_0023:
{
bool L_5 = V_1;
return L_5;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Ray)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_m111AFC36A136A67BE4776670E356E99A82010BFE (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
bool L_3;
L_3 = PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, (std::numeric_limits<float>::infinity()), ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_3;
goto IL_0027;
}
IL_0027:
{
bool L_4 = V_1;
return L_4;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Ray,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_mCA3F2DD1DC08199AAD8466BB857318CD454AC774 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_3 = ___hitInfo1;
float L_4 = ___maxDistance2;
int32_t L_5 = ___layerMask3;
int32_t L_6 = ___queryTriggerInteraction4;
bool L_7;
L_7 = PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_3, L_4, L_5, L_6, /*hidden argument*/NULL);
V_1 = L_7;
goto IL_0024;
}
IL_0024:
{
bool L_8 = V_1;
return L_8;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Ray,UnityEngine.RaycastHit&,System.Single,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_m46E12070D6996F4C8C91D49ADC27C74AC1D6A3D8 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo1, float ___maxDistance2, int32_t ___layerMask3, const RuntimeMethod* method)
{
bool V_0 = false;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0;
L_0 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_2 = ___hitInfo1;
float L_3 = ___maxDistance2;
int32_t L_4 = ___layerMask3;
bool L_5;
L_5 = Physics_Raycast_m2EA572B4613E1BD7DBAA299511CFD2DBA179A163(L_0, L_1, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_2, L_3, L_4, 0, /*hidden argument*/NULL);
V_0 = L_5;
goto IL_001b;
}
IL_001b:
{
bool L_6 = V_0;
return L_6;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Ray,UnityEngine.RaycastHit&,System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_mA64F8C30681E3A6A8F2B7EDE592FE7BBC0D354F4 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo1, float ___maxDistance2, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_3 = ___hitInfo1;
float L_4 = ___maxDistance2;
bool L_5;
L_5 = PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_3, L_4, ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_5;
goto IL_0024;
}
IL_0024:
{
bool L_6 = V_1;
return L_6;
}
}
// System.Boolean UnityEngine.Physics::Raycast(UnityEngine.Ray,UnityEngine.RaycastHit&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Raycast_m80EC8EEDA0ABA8B01838BA9054834CD1A381916E (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo1, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_3 = ___hitInfo1;
bool L_4;
L_4 = PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_3, (std::numeric_limits<float>::infinity()), ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_4;
goto IL_0028;
}
IL_0028:
{
bool L_5 = V_1;
return L_5;
}
}
// System.Boolean UnityEngine.Physics::Linecast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Linecast_m0962EAB4C29037847AD41F571E88D54827CDC9A6 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___start0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___end1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_1;
memset((&V_1), 0, sizeof(V_1));
bool V_2 = false;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___end1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___start0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Vector3_op_Subtraction_m2725C96965D5C0B1F9715797E51762B13A5FED58_inline(L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_3;
L_3 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_1 = L_3;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_4 = ___start0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_5 = V_0;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_6 = ___hitInfo2;
float L_7;
L_7 = Vector3_get_magnitude_mDDD40612220D8104E77E993E18A101A69A944991((Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
int32_t L_8 = ___layerMask3;
int32_t L_9 = ___queryTriggerInteraction4;
bool L_10;
L_10 = PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_1), L_4, L_5, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_6, L_7, L_8, L_9, /*hidden argument*/NULL);
V_2 = L_10;
goto IL_0026;
}
IL_0026:
{
bool L_11 = V_2;
return L_11;
}
}
// System.Boolean UnityEngine.Physics::Linecast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Linecast_m2FA86FE1252E087C1F9D5651FCA742A4B0ED9AEF (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___start0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___end1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, const RuntimeMethod* method)
{
bool V_0 = false;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___start0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___end1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_2 = ___hitInfo2;
bool L_3;
L_3 = Physics_Linecast_m0962EAB4C29037847AD41F571E88D54827CDC9A6(L_0, L_1, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_2, ((int32_t)-5), 0, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_000f;
}
IL_000f:
{
bool L_4 = V_0;
return L_4;
}
}
// System.Boolean UnityEngine.Physics::SphereCast(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_SphereCast_m3179B64AAFD6E888FF0A9CBB967CE342529C333D (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo3, float ___maxDistance4, int32_t ___layerMask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
float L_2 = ___radius1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_3 = ___direction2;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_4 = ___hitInfo3;
float L_5 = ___maxDistance4;
int32_t L_6 = ___layerMask5;
int32_t L_7 = ___queryTriggerInteraction6;
bool L_8;
L_8 = PhysicsScene_SphereCast_m72928994362EE11F9A4F72BD79954444B9FD1C2D((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_4, L_5, L_6, L_7, /*hidden argument*/NULL);
V_1 = L_8;
goto IL_001b;
}
IL_001b:
{
bool L_9 = V_1;
return L_9;
}
}
// System.Boolean UnityEngine.Physics::SphereCast(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_SphereCast_m9943744EA02A42417719F4A0CBE5822DA12F15BC (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo3, float ___maxDistance4, int32_t ___layerMask5, const RuntimeMethod* method)
{
bool V_0 = false;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___origin0;
float L_1 = ___radius1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction2;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_3 = ___hitInfo3;
float L_4 = ___maxDistance4;
int32_t L_5 = ___layerMask5;
bool L_6;
L_6 = Physics_SphereCast_m3179B64AAFD6E888FF0A9CBB967CE342529C333D(L_0, L_1, L_2, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_3, L_4, L_5, 0, /*hidden argument*/NULL);
V_0 = L_6;
goto IL_0012;
}
IL_0012:
{
bool L_7 = V_0;
return L_7;
}
}
// System.Boolean UnityEngine.Physics::SphereCast(UnityEngine.Ray,System.Single,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_SphereCast_mF2EE3CD3E7169B32E5BCCEEC2EED4D2759E6CB36 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___radius1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0;
L_0 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
float L_1 = ___radius1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
float L_3 = ___maxDistance2;
int32_t L_4 = ___layerMask3;
int32_t L_5 = ___queryTriggerInteraction4;
bool L_6;
L_6 = Physics_SphereCast_m3179B64AAFD6E888FF0A9CBB967CE342529C333D(L_0, L_1, L_2, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)(&V_0), L_3, L_4, L_5, /*hidden argument*/NULL);
V_1 = L_6;
goto IL_001e;
}
IL_001e:
{
bool L_7 = V_1;
return L_7;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::Internal_RaycastAll(UnityEngine.PhysicsScene,UnityEngine.Ray,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_Internal_RaycastAll_m39EE7CF896F9D8BA58CC623F14E4DB0641480523 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray1, float ___maxDistance2, int32_t ___mask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
{
float L_0 = ___maxDistance2;
int32_t L_1 = ___mask3;
int32_t L_2 = ___queryTriggerInteraction4;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3;
L_3 = Physics_Internal_RaycastAll_Injected_mD4C3E8762D9FCEE654CE0415E636EB7DBEC92A5B((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&___physicsScene0), (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray1), L_0, L_1, L_2, /*hidden argument*/NULL);
return L_3;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::RaycastAll(UnityEngine.Vector3,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_RaycastAll_m5103E7C60CC66BAFA6534D1736138A92EB1EF2B8 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
bool V_1 = false;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_2;
memset((&V_2), 0, sizeof(V_2));
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 V_3;
memset((&V_3), 0, sizeof(V_3));
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_4 = NULL;
{
float L_0;
L_0 = Vector3_get_magnitude_mDDD40612220D8104E77E993E18A101A69A944991((Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction1), /*hidden argument*/NULL);
V_0 = L_0;
float L_1 = V_0;
V_1 = (bool)((((float)L_1) > ((float)(1.40129846E-45f)))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_003a;
}
}
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_3 = ___direction1;
float L_4 = V_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_5;
L_5 = Vector3_op_Division_mE5ACBFB168FED529587457A83BA98B7DB32E2A05_inline(L_3, L_4, /*hidden argument*/NULL);
V_2 = L_5;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_6 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_7 = V_2;
Ray__ctor_m75B1F651FF47EE6B887105101B7DA61CBF41F83C((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&V_3), L_6, L_7, /*hidden argument*/NULL);
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_8;
L_8 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 L_9 = V_3;
float L_10 = ___maxDistance2;
int32_t L_11 = ___layerMask3;
int32_t L_12 = ___queryTriggerInteraction4;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_13;
L_13 = Physics_Internal_RaycastAll_m39EE7CF896F9D8BA58CC623F14E4DB0641480523(L_8, L_9, L_10, L_11, L_12, /*hidden argument*/NULL);
V_4 = L_13;
goto IL_0045;
}
IL_003a:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_14 = (RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09*)(RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09*)SZArrayNew(RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09_il2cpp_TypeInfo_var, (uint32_t)0);
V_4 = L_14;
goto IL_0045;
}
IL_0045:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_15 = V_4;
return L_15;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::RaycastAll(UnityEngine.Vector3,UnityEngine.Vector3,System.Single,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_RaycastAll_m2C977C8B022672F42B5E18F40B529C0A74B7E471 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, float ___maxDistance2, int32_t ___layerMask3, const RuntimeMethod* method)
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_0 = NULL;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___direction1;
float L_2 = ___maxDistance2;
int32_t L_3 = ___layerMask3;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_4;
L_4 = Physics_RaycastAll_m5103E7C60CC66BAFA6534D1736138A92EB1EF2B8(L_0, L_1, L_2, L_3, 0, /*hidden argument*/NULL);
V_0 = L_4;
goto IL_000e;
}
IL_000e:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_5 = V_0;
return L_5;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::RaycastAll(UnityEngine.Vector3,UnityEngine.Vector3,System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_RaycastAll_m2BBC8D2731B38EE0B704A5C6A09D0F8BBA074A4D (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, float ___maxDistance2, const RuntimeMethod* method)
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_0 = NULL;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___direction1;
float L_2 = ___maxDistance2;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3;
L_3 = Physics_RaycastAll_m5103E7C60CC66BAFA6534D1736138A92EB1EF2B8(L_0, L_1, L_2, ((int32_t)-5), 0, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_000f;
}
IL_000f:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_4 = V_0;
return L_4;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::RaycastAll(UnityEngine.Vector3,UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_RaycastAll_m83F28CB671653C07995FB1BCDC561121DE3D9CA6 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, const RuntimeMethod* method)
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_0 = NULL;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___direction1;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_2;
L_2 = Physics_RaycastAll_m5103E7C60CC66BAFA6534D1736138A92EB1EF2B8(L_0, L_1, (std::numeric_limits<float>::infinity()), ((int32_t)-5), 0, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0013;
}
IL_0013:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = V_0;
return L_3;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::RaycastAll(UnityEngine.Ray,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_RaycastAll_m55EB4478198ED6EF838500257FA3BE1A871D3605 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___maxDistance1, int32_t ___layerMask2, int32_t ___queryTriggerInteraction3, const RuntimeMethod* method)
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_0 = NULL;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0;
L_0 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
float L_2 = ___maxDistance1;
int32_t L_3 = ___layerMask2;
int32_t L_4 = ___queryTriggerInteraction3;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_5;
L_5 = Physics_RaycastAll_m5103E7C60CC66BAFA6534D1736138A92EB1EF2B8(L_0, L_1, L_2, L_3, L_4, /*hidden argument*/NULL);
V_0 = L_5;
goto IL_001a;
}
IL_001a:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_6 = V_0;
return L_6;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::RaycastAll(UnityEngine.Ray,System.Single,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_RaycastAll_mA24B9B922C98C5D18397FAE55C04AEAFDD47F029 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___maxDistance1, int32_t ___layerMask2, const RuntimeMethod* method)
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_0 = NULL;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0;
L_0 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
float L_2 = ___maxDistance1;
int32_t L_3 = ___layerMask2;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_4;
L_4 = Physics_RaycastAll_m5103E7C60CC66BAFA6534D1736138A92EB1EF2B8(L_0, L_1, L_2, L_3, 0, /*hidden argument*/NULL);
V_0 = L_4;
goto IL_001a;
}
IL_001a:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_5 = V_0;
return L_5;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::RaycastAll(UnityEngine.Ray,System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_RaycastAll_m72947571EFB0EFB34E48340AA2EC0C8030D27C50 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___maxDistance1, const RuntimeMethod* method)
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_0 = NULL;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0;
L_0 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
float L_2 = ___maxDistance1;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3;
L_3 = Physics_RaycastAll_m5103E7C60CC66BAFA6534D1736138A92EB1EF2B8(L_0, L_1, L_2, ((int32_t)-5), 0, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_001b;
}
IL_001b:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_4 = V_0;
return L_4;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::RaycastAll(UnityEngine.Ray)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_RaycastAll_m529EE59D6D03E4CFAECE4016C8CC4181BEC2D26D (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, const RuntimeMethod* method)
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_0 = NULL;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0;
L_0 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_2;
L_2 = Physics_RaycastAll_m5103E7C60CC66BAFA6534D1736138A92EB1EF2B8(L_0, L_1, (std::numeric_limits<float>::infinity()), ((int32_t)-5), 0, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_001f;
}
IL_001f:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = V_0;
return L_3;
}
}
// System.Int32 UnityEngine.Physics::RaycastNonAlloc(UnityEngine.Ray,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_RaycastNonAlloc_m7C81125AD7D5891EBC3AB48C6DED7B60F53DF099 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = ___results1;
float L_4 = ___maxDistance2;
int32_t L_5 = ___layerMask3;
int32_t L_6 = ___queryTriggerInteraction4;
int32_t L_7;
L_7 = PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, L_5, L_6, /*hidden argument*/NULL);
V_1 = L_7;
goto IL_0024;
}
IL_0024:
{
int32_t L_8 = V_1;
return L_8;
}
}
// System.Int32 UnityEngine.Physics::RaycastNonAlloc(UnityEngine.Ray,UnityEngine.RaycastHit[],System.Single,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_RaycastNonAlloc_m8F62EE5A33E81A02E4983A171023B7BC4AC700CA (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results1, float ___maxDistance2, int32_t ___layerMask3, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = ___results1;
float L_4 = ___maxDistance2;
int32_t L_5 = ___layerMask3;
int32_t L_6;
L_6 = PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, L_5, 0, /*hidden argument*/NULL);
V_1 = L_6;
goto IL_0023;
}
IL_0023:
{
int32_t L_7 = V_1;
return L_7;
}
}
// System.Int32 UnityEngine.Physics::RaycastNonAlloc(UnityEngine.Ray,UnityEngine.RaycastHit[],System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_RaycastNonAlloc_m41BB7BB8755B09700C10F59A29C3541D45AB9CCD (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results1, float ___maxDistance2, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = ___results1;
float L_4 = ___maxDistance2;
int32_t L_5;
L_5 = PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_5;
goto IL_0024;
}
IL_0024:
{
int32_t L_6 = V_1;
return L_6;
}
}
// System.Int32 UnityEngine.Physics::RaycastNonAlloc(UnityEngine.Ray,UnityEngine.RaycastHit[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_RaycastNonAlloc_mBC5BE514E55B8D98A8F4752DED6850E02EE8AD98 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results1, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = ___results1;
int32_t L_4;
L_4 = PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, (std::numeric_limits<float>::infinity()), ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_4;
goto IL_0028;
}
IL_0028:
{
int32_t L_5 = V_1;
return L_5;
}
}
// System.Int32 UnityEngine.Physics::RaycastNonAlloc(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_RaycastNonAlloc_m2C90D14E472DE7929EFD54FDA7BC512D3FBDE4ED (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = ___results2;
float L_4 = ___maxDistance3;
int32_t L_5 = ___layerMask4;
int32_t L_6 = ___queryTriggerInteraction5;
int32_t L_7;
L_7 = PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, L_5, L_6, /*hidden argument*/NULL);
V_1 = L_7;
goto IL_0019;
}
IL_0019:
{
int32_t L_8 = V_1;
return L_8;
}
}
// System.Int32 UnityEngine.Physics::RaycastNonAlloc(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_RaycastNonAlloc_m316F597067055C9F923F57CC68D68FF917C3B4D1 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results2, float ___maxDistance3, int32_t ___layerMask4, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = ___results2;
float L_4 = ___maxDistance3;
int32_t L_5 = ___layerMask4;
int32_t L_6;
L_6 = PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, L_5, 0, /*hidden argument*/NULL);
V_1 = L_6;
goto IL_0018;
}
IL_0018:
{
int32_t L_7 = V_1;
return L_7;
}
}
// System.Int32 UnityEngine.Physics::RaycastNonAlloc(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_RaycastNonAlloc_m1B8F31BF41F756F561F6AC3A2E0736F2BC9C4DB4 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results2, float ___maxDistance3, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = ___results2;
float L_4 = ___maxDistance3;
int32_t L_5;
L_5 = PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_5;
goto IL_0018;
}
IL_0018:
{
int32_t L_6 = V_1;
return L_6;
}
}
// System.Int32 UnityEngine.Physics::RaycastNonAlloc(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_RaycastNonAlloc_m9076DDE1A65F87DB3D2824DAD4E5B8B534159F1F (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results2, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction1;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = ___results2;
int32_t L_4;
L_4 = PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, (std::numeric_limits<float>::infinity()), ((int32_t)-5), 0, /*hidden argument*/NULL);
V_1 = L_4;
goto IL_001c;
}
IL_001c:
{
int32_t L_5 = V_1;
return L_5;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::Query_SphereCastAll(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_Query_SphereCastAll_m290982F68113941617D41D76F6BA6A1691688701 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction3, float ___maxDistance4, int32_t ___mask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method)
{
{
float L_0 = ___radius2;
float L_1 = ___maxDistance4;
int32_t L_2 = ___mask5;
int32_t L_3 = ___queryTriggerInteraction6;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_4;
L_4 = Physics_Query_SphereCastAll_Injected_mE9FEF854EB63E9814AE2A53400ABD8A0C116A17E((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&___physicsScene0), (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___origin1), L_0, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction3), L_1, L_2, L_3, /*hidden argument*/NULL);
return L_4;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::SphereCastAll(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_SphereCastAll_m819438325E419C699AE3245CB9C08B300A6CFCD9 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
bool V_1 = false;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_2;
memset((&V_2), 0, sizeof(V_2));
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_3 = NULL;
{
float L_0;
L_0 = Vector3_get_magnitude_mDDD40612220D8104E77E993E18A101A69A944991((Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction2), /*hidden argument*/NULL);
V_0 = L_0;
float L_1 = V_0;
V_1 = (bool)((((float)L_1) > ((float)(1.40129846E-45f)))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_0033;
}
}
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_3 = ___direction2;
float L_4 = V_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_5;
L_5 = Vector3_op_Division_mE5ACBFB168FED529587457A83BA98B7DB32E2A05_inline(L_3, L_4, /*hidden argument*/NULL);
V_2 = L_5;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_6;
L_6 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_7 = ___origin0;
float L_8 = ___radius1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_9 = V_2;
float L_10 = ___maxDistance3;
int32_t L_11 = ___layerMask4;
int32_t L_12 = ___queryTriggerInteraction5;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_13;
L_13 = Physics_Query_SphereCastAll_m290982F68113941617D41D76F6BA6A1691688701(L_6, L_7, L_8, L_9, L_10, L_11, L_12, /*hidden argument*/NULL);
V_3 = L_13;
goto IL_003d;
}
IL_0033:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_14 = (RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09*)(RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09*)SZArrayNew(RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09_il2cpp_TypeInfo_var, (uint32_t)0);
V_3 = L_14;
goto IL_003d;
}
IL_003d:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_15 = V_3;
return L_15;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::SphereCastAll(UnityEngine.Ray,System.Single,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_SphereCastAll_m33BB4ED4BCC53FDCE44B4236ABE0C452BB352C9E (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___radius1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_0 = NULL;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0;
L_0 = Ray_get_origin_m0C1B2BFF99CDF5231AC29AC031C161F55B53C1D0((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
float L_1 = ___radius1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2;
L_2 = Ray_get_direction_m2B31F86F19B64474A901B28D3808011AE7A13EFC((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray0), /*hidden argument*/NULL);
float L_3 = ___maxDistance2;
int32_t L_4 = ___layerMask3;
int32_t L_5 = ___queryTriggerInteraction4;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_6;
L_6 = Physics_SphereCastAll_m819438325E419C699AE3245CB9C08B300A6CFCD9(L_0, L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
V_0 = L_6;
goto IL_001c;
}
IL_001c:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_7 = V_0;
return L_7;
}
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::SphereCastAll(UnityEngine.Ray,System.Single,System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_SphereCastAll_m237B3FE8A8FFF578B922DD8574AE8628DDA22FA5 (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray0, float ___radius1, float ___maxDistance2, const RuntimeMethod* method)
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* V_0 = NULL;
{
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 L_0 = ___ray0;
float L_1 = ___radius1;
float L_2 = ___maxDistance2;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3;
L_3 = Physics_SphereCastAll_m33BB4ED4BCC53FDCE44B4236ABE0C452BB352C9E(L_0, L_1, L_2, ((int32_t)-5), 0, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_000f;
}
IL_000f:
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_4 = V_0;
return L_4;
}
}
// UnityEngine.Collider[] UnityEngine.Physics::OverlapSphere_Internal(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* Physics_OverlapSphere_Internal_m92572431C76930C21D10CEFC0F0D37B945A6F4FF (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position1, float ___radius2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
{
float L_0 = ___radius2;
int32_t L_1 = ___layerMask3;
int32_t L_2 = ___queryTriggerInteraction4;
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* L_3;
L_3 = Physics_OverlapSphere_Internal_Injected_mBC7164D0CB4C0ED3299EE6515F162F324C16D291((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&___physicsScene0), (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___position1), L_0, L_1, L_2, /*hidden argument*/NULL);
return L_3;
}
}
// UnityEngine.Collider[] UnityEngine.Physics::OverlapSphere(UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* Physics_OverlapSphere_m1CDA8916BA89EE2B497158A08CD571044D60054B (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, float ___radius1, int32_t ___layerMask2, int32_t ___queryTriggerInteraction3, const RuntimeMethod* method)
{
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* V_0 = NULL;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___position0;
float L_2 = ___radius1;
int32_t L_3 = ___layerMask2;
int32_t L_4 = ___queryTriggerInteraction3;
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* L_5;
L_5 = Physics_OverlapSphere_Internal_m92572431C76930C21D10CEFC0F0D37B945A6F4FF(L_0, L_1, L_2, L_3, L_4, /*hidden argument*/NULL);
V_0 = L_5;
goto IL_0012;
}
IL_0012:
{
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* L_6 = V_0;
return L_6;
}
}
// UnityEngine.Collider[] UnityEngine.Physics::OverlapSphere(UnityEngine.Vector3,System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* Physics_OverlapSphere_mE4A0577DF7C0681DE7FFC4F2A2C1BFB8D402CA0C (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, float ___radius1, const RuntimeMethod* method)
{
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* V_0 = NULL;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___position0;
float L_1 = ___radius1;
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* L_2;
L_2 = Physics_OverlapSphere_m1CDA8916BA89EE2B497158A08CD571044D60054B(L_0, L_1, (-1), 0, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_000d;
}
IL_000d:
{
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* L_3 = V_0;
return L_3;
}
}
// System.Void UnityEngine.Physics::SyncTransforms()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Physics_SyncTransforms_m744C6ED0B04CAB03C7D5A7320896AE3B6D4674D1 (const RuntimeMethod* method)
{
typedef void (*Physics_SyncTransforms_m744C6ED0B04CAB03C7D5A7320896AE3B6D4674D1_ftn) ();
static Physics_SyncTransforms_m744C6ED0B04CAB03C7D5A7320896AE3B6D4674D1_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics_SyncTransforms_m744C6ED0B04CAB03C7D5A7320896AE3B6D4674D1_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics::SyncTransforms()");
_il2cpp_icall_func();
}
// System.Boolean UnityEngine.Physics::Query_ComputePenetration(UnityEngine.Collider,UnityEngine.Vector3,UnityEngine.Quaternion,UnityEngine.Collider,UnityEngine.Vector3,UnityEngine.Quaternion,UnityEngine.Vector3&,System.Single&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Query_ComputePenetration_m6B55B585ECB5C4EF7A699781719BC23A8638103D (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___colliderA0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___positionA1, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___rotationA2, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___colliderB3, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___positionB4, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___rotationB5, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction6, float* ___distance7, const RuntimeMethod* method)
{
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_0 = ___colliderA0;
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_1 = ___colliderB3;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * L_2 = ___direction6;
float* L_3 = ___distance7;
bool L_4;
L_4 = Physics_Query_ComputePenetration_Injected_mF8C23B35E141DFDE213242F410BC8B89159B22A9(L_0, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___positionA1), (Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 *)(&___rotationA2), L_1, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___positionB4), (Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 *)(&___rotationB5), (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)L_2, (float*)L_3, /*hidden argument*/NULL);
return L_4;
}
}
// System.Boolean UnityEngine.Physics::ComputePenetration(UnityEngine.Collider,UnityEngine.Vector3,UnityEngine.Quaternion,UnityEngine.Collider,UnityEngine.Vector3,UnityEngine.Quaternion,UnityEngine.Vector3&,System.Single&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_ComputePenetration_m1F892D7CBF091AB513D0DA638E4718D8AC7769D4 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___colliderA0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___positionA1, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___rotationA2, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___colliderB3, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___positionB4, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___rotationB5, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction6, float* ___distance7, const RuntimeMethod* method)
{
bool V_0 = false;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * L_0 = ___direction6;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1;
L_1 = Vector3_get_zero_m1A8F7993167785F750B6B01762D22C2597C84EF6(/*hidden argument*/NULL);
*(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)L_0 = L_1;
float* L_2 = ___distance7;
*((float*)L_2) = (float)(0.0f);
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_3 = ___colliderA0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_4 = ___positionA1;
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 L_5 = ___rotationA2;
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_6 = ___colliderB3;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_7 = ___positionB4;
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 L_8 = ___rotationB5;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * L_9 = ___direction6;
float* L_10 = ___distance7;
bool L_11;
L_11 = Physics_Query_ComputePenetration_m6B55B585ECB5C4EF7A699781719BC23A8638103D(L_3, L_4, L_5, L_6, L_7, L_8, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)L_9, (float*)L_10, /*hidden argument*/NULL);
V_0 = L_11;
goto IL_0029;
}
IL_0029:
{
bool L_12 = V_0;
return L_12;
}
}
// System.Int32 UnityEngine.Physics::OverlapSphereNonAlloc(UnityEngine.Vector3,System.Single,UnityEngine.Collider[],System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_OverlapSphereNonAlloc_mD1A616CEF8B7C991A9E56B7E17FF5BCF7C4B8431 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, float ___radius1, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* ___results2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___position0;
float L_2 = ___radius1;
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* L_3 = ___results2;
int32_t L_4 = ___layerMask3;
int32_t L_5 = ___queryTriggerInteraction4;
int32_t L_6;
L_6 = PhysicsScene_OverlapSphere_mBFBB0C810534D52967EE4FDC97DB67301D769ACC((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
V_1 = L_6;
goto IL_0017;
}
IL_0017:
{
int32_t L_7 = V_1;
return L_7;
}
}
// System.Int32 UnityEngine.Physics::OverlapSphereNonAlloc(UnityEngine.Vector3,System.Single,UnityEngine.Collider[],System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_OverlapSphereNonAlloc_mFF7251F5196681A06A2B4E770D8E54DC80B34B4D (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, float ___radius1, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* ___results2, int32_t ___layerMask3, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___position0;
float L_1 = ___radius1;
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* L_2 = ___results2;
int32_t L_3 = ___layerMask3;
int32_t L_4;
L_4 = Physics_OverlapSphereNonAlloc_mD1A616CEF8B7C991A9E56B7E17FF5BCF7C4B8431(L_0, L_1, L_2, L_3, 0, /*hidden argument*/NULL);
V_0 = L_4;
goto IL_000e;
}
IL_000e:
{
int32_t L_5 = V_0;
return L_5;
}
}
// System.Int32 UnityEngine.Physics::SphereCastNonAlloc(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_SphereCastNonAlloc_m9635CF65AE04223E3A6DF9E7B860D9C7B8E984E7 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results3, float ___maxDistance4, int32_t ___layerMask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method)
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0;
L_0 = Physics_get_defaultPhysicsScene_mA6361488FBAC110DA8397E5E4CB473EBF4191010(/*hidden argument*/NULL);
V_0 = L_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
float L_2 = ___radius1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_3 = ___direction2;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_4 = ___results3;
float L_5 = ___maxDistance4;
int32_t L_6 = ___layerMask5;
int32_t L_7 = ___queryTriggerInteraction6;
int32_t L_8;
L_8 = PhysicsScene_SphereCast_m36723F888676E712CC40A0E54D72E95F73D193D3((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&V_0), L_1, L_2, L_3, L_4, L_5, L_6, L_7, /*hidden argument*/NULL);
V_1 = L_8;
goto IL_001b;
}
IL_001b:
{
int32_t L_9 = V_1;
return L_9;
}
}
// System.Int32 UnityEngine.Physics::SphereCastNonAlloc(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Physics_SphereCastNonAlloc_mC12BE8DA1DE96ADB864398FB58274119E5569493 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results3, float ___maxDistance4, int32_t ___layerMask5, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___origin0;
float L_1 = ___radius1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___direction2;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_3 = ___results3;
float L_4 = ___maxDistance4;
int32_t L_5 = ___layerMask5;
int32_t L_6;
L_6 = Physics_SphereCastNonAlloc_m9635CF65AE04223E3A6DF9E7B860D9C7B8E984E7(L_0, L_1, L_2, L_3, L_4, L_5, 0, /*hidden argument*/NULL);
V_0 = L_6;
goto IL_0012;
}
IL_0012:
{
int32_t L_7 = V_0;
return L_7;
}
}
// System.Void UnityEngine.Physics::get_gravity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Physics_get_gravity_Injected_mC0C1A2C9C0490972A162C313425CFC05BDE6C892 (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method)
{
typedef void (*Physics_get_gravity_Injected_mC0C1A2C9C0490972A162C313425CFC05BDE6C892_ftn) (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static Physics_get_gravity_Injected_mC0C1A2C9C0490972A162C313425CFC05BDE6C892_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics_get_gravity_Injected_mC0C1A2C9C0490972A162C313425CFC05BDE6C892_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics::get_gravity_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(___ret0);
}
// System.Void UnityEngine.Physics::get_defaultPhysicsScene_Injected(UnityEngine.PhysicsScene&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Physics_get_defaultPhysicsScene_Injected_m0B71068269B3C8499A258BBCAEA7E3D9D020BADA (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___ret0, const RuntimeMethod* method)
{
typedef void (*Physics_get_defaultPhysicsScene_Injected_m0B71068269B3C8499A258BBCAEA7E3D9D020BADA_ftn) (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *);
static Physics_get_defaultPhysicsScene_Injected_m0B71068269B3C8499A258BBCAEA7E3D9D020BADA_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics_get_defaultPhysicsScene_Injected_m0B71068269B3C8499A258BBCAEA7E3D9D020BADA_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics::get_defaultPhysicsScene_Injected(UnityEngine.PhysicsScene&)");
_il2cpp_icall_func(___ret0);
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::Internal_RaycastAll_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_Internal_RaycastAll_Injected_mD4C3E8762D9FCEE654CE0415E636EB7DBEC92A5B (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * ___ray1, float ___maxDistance2, int32_t ___mask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
typedef RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* (*Physics_Internal_RaycastAll_Injected_mD4C3E8762D9FCEE654CE0415E636EB7DBEC92A5B_ftn) (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *, float, int32_t, int32_t);
static Physics_Internal_RaycastAll_Injected_mD4C3E8762D9FCEE654CE0415E636EB7DBEC92A5B_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics_Internal_RaycastAll_Injected_mD4C3E8762D9FCEE654CE0415E636EB7DBEC92A5B_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics::Internal_RaycastAll_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)");
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* icallRetVal = _il2cpp_icall_func(___physicsScene0, ___ray1, ___maxDistance2, ___mask3, ___queryTriggerInteraction4);
return icallRetVal;
}
// UnityEngine.RaycastHit[] UnityEngine.Physics::Query_SphereCastAll_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Vector3&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* Physics_Query_SphereCastAll_Injected_mE9FEF854EB63E9814AE2A53400ABD8A0C116A17E (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction3, float ___maxDistance4, int32_t ___mask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method)
{
typedef RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* (*Physics_Query_SphereCastAll_Injected_mE9FEF854EB63E9814AE2A53400ABD8A0C116A17E_ftn) (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, float, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, float, int32_t, int32_t);
static Physics_Query_SphereCastAll_Injected_mE9FEF854EB63E9814AE2A53400ABD8A0C116A17E_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics_Query_SphereCastAll_Injected_mE9FEF854EB63E9814AE2A53400ABD8A0C116A17E_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics::Query_SphereCastAll_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Vector3&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)");
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* icallRetVal = _il2cpp_icall_func(___physicsScene0, ___origin1, ___radius2, ___direction3, ___maxDistance4, ___mask5, ___queryTriggerInteraction6);
return icallRetVal;
}
// UnityEngine.Collider[] UnityEngine.Physics::OverlapSphere_Internal_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* Physics_OverlapSphere_Internal_Injected_mBC7164D0CB4C0ED3299EE6515F162F324C16D291 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___position1, float ___radius2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
typedef ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* (*Physics_OverlapSphere_Internal_Injected_mBC7164D0CB4C0ED3299EE6515F162F324C16D291_ftn) (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, float, int32_t, int32_t);
static Physics_OverlapSphere_Internal_Injected_mBC7164D0CB4C0ED3299EE6515F162F324C16D291_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics_OverlapSphere_Internal_Injected_mBC7164D0CB4C0ED3299EE6515F162F324C16D291_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics::OverlapSphere_Internal_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)");
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* icallRetVal = _il2cpp_icall_func(___physicsScene0, ___position1, ___radius2, ___layerMask3, ___queryTriggerInteraction4);
return icallRetVal;
}
// System.Boolean UnityEngine.Physics::Query_ComputePenetration_Injected(UnityEngine.Collider,UnityEngine.Vector3&,UnityEngine.Quaternion&,UnityEngine.Collider,UnityEngine.Vector3&,UnityEngine.Quaternion&,UnityEngine.Vector3&,System.Single&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Physics_Query_ComputePenetration_Injected_mF8C23B35E141DFDE213242F410BC8B89159B22A9 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___colliderA0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___positionA1, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * ___rotationA2, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___colliderB3, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___positionB4, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * ___rotationB5, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction6, float* ___distance7, const RuntimeMethod* method)
{
typedef bool (*Physics_Query_ComputePenetration_Injected_mF8C23B35E141DFDE213242F410BC8B89159B22A9_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 *, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, float*);
static Physics_Query_ComputePenetration_Injected_mF8C23B35E141DFDE213242F410BC8B89159B22A9_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics_Query_ComputePenetration_Injected_mF8C23B35E141DFDE213242F410BC8B89159B22A9_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics::Query_ComputePenetration_Injected(UnityEngine.Collider,UnityEngine.Vector3&,UnityEngine.Quaternion&,UnityEngine.Collider,UnityEngine.Vector3&,UnityEngine.Quaternion&,UnityEngine.Vector3&,System.Single&)");
bool icallRetVal = _il2cpp_icall_func(___colliderA0, ___positionA1, ___rotationA2, ___colliderB3, ___positionB4, ___rotationB5, ___direction6, ___distance7);
return icallRetVal;
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.String UnityEngine.PhysicsScene::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* PhysicsScene_ToString_mBB6D0AC1E3E2EDC34CB4A7A34485B24B6271903F (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral21ACE806CE655297BC379B3AD17E97F0A68B6AEC);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* L_0 = (ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE*)(ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE*)SZArrayNew(ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE_il2cpp_TypeInfo_var, (uint32_t)1);
ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* L_1 = L_0;
int32_t L_2 = __this->get_m_Handle_0();
int32_t L_3 = L_2;
RuntimeObject * L_4 = Box(Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046_il2cpp_TypeInfo_var, &L_3);
NullCheck(L_1);
ArrayElementTypeCheck (L_1, L_4);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)L_4);
String_t* L_5;
L_5 = UnityString_Format_m7A07C068ED408DD06F634070770FB55F13AA4EC9(_stringLiteral21ACE806CE655297BC379B3AD17E97F0A68B6AEC, L_1, /*hidden argument*/NULL);
V_0 = L_5;
goto IL_0022;
}
IL_0022:
{
String_t* L_6 = V_0;
return L_6;
}
}
IL2CPP_EXTERN_C String_t* PhysicsScene_ToString_mBB6D0AC1E3E2EDC34CB4A7A34485B24B6271903F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * _thisAdjusted = reinterpret_cast<PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *>(__this + _offset);
String_t* _returnValue;
_returnValue = PhysicsScene_ToString_mBB6D0AC1E3E2EDC34CB4A7A34485B24B6271903F(_thisAdjusted, method);
return _returnValue;
}
// System.Int32 UnityEngine.PhysicsScene::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_GetHashCode_m5344CC6CCCB1CA6EBB149775EE028089DD74B8A2 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_m_Handle_0();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
int32_t L_1 = V_0;
return L_1;
}
}
IL2CPP_EXTERN_C int32_t PhysicsScene_GetHashCode_m5344CC6CCCB1CA6EBB149775EE028089DD74B8A2_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * _thisAdjusted = reinterpret_cast<PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *>(__this + _offset);
int32_t _returnValue;
_returnValue = PhysicsScene_GetHashCode_m5344CC6CCCB1CA6EBB149775EE028089DD74B8A2(_thisAdjusted, method);
return _returnValue;
}
// System.Boolean UnityEngine.PhysicsScene::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Equals_m2645ABB96C598F197F734EB712494795928CBCEC (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, RuntimeObject * ___other0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
bool V_2 = false;
{
RuntimeObject * L_0 = ___other0;
V_1 = (bool)((((int32_t)((!(((RuntimeObject*)(RuntimeObject *)((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678_il2cpp_TypeInfo_var))) <= ((RuntimeObject*)(RuntimeObject *)NULL)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
bool L_1 = V_1;
if (!L_1)
{
goto IL_0015;
}
}
{
V_2 = (bool)0;
goto IL_002d;
}
IL_0015:
{
RuntimeObject * L_2 = ___other0;
V_0 = ((*(PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)UnBox(L_2, PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678_il2cpp_TypeInfo_var))));
int32_t L_3 = __this->get_m_Handle_0();
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_4 = V_0;
int32_t L_5 = L_4.get_m_Handle_0();
V_2 = (bool)((((int32_t)L_3) == ((int32_t)L_5))? 1 : 0);
goto IL_002d;
}
IL_002d:
{
bool L_6 = V_2;
return L_6;
}
}
IL2CPP_EXTERN_C bool PhysicsScene_Equals_m2645ABB96C598F197F734EB712494795928CBCEC_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___other0, const RuntimeMethod* method)
{
int32_t _offset = 1;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * _thisAdjusted = reinterpret_cast<PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *>(__this + _offset);
bool _returnValue;
_returnValue = PhysicsScene_Equals_m2645ABB96C598F197F734EB712494795928CBCEC(_thisAdjusted, ___other0, method);
return _returnValue;
}
// System.Boolean UnityEngine.PhysicsScene::Equals(UnityEngine.PhysicsScene)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Equals_m8C948B86D105177D519A3608816CDC698C8686B8 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___other0, const RuntimeMethod* method)
{
bool V_0 = false;
{
int32_t L_0 = __this->get_m_Handle_0();
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_1 = ___other0;
int32_t L_2 = L_1.get_m_Handle_0();
V_0 = (bool)((((int32_t)L_0) == ((int32_t)L_2))? 1 : 0);
goto IL_0012;
}
IL_0012:
{
bool L_3 = V_0;
return L_3;
}
}
IL2CPP_EXTERN_C bool PhysicsScene_Equals_m8C948B86D105177D519A3608816CDC698C8686B8_AdjustorThunk (RuntimeObject * __this, PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___other0, const RuntimeMethod* method)
{
int32_t _offset = 1;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * _thisAdjusted = reinterpret_cast<PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *>(__this + _offset);
bool _returnValue;
_returnValue = PhysicsScene_Equals_m8C948B86D105177D519A3608816CDC698C8686B8(_thisAdjusted, ___other0, method);
return _returnValue;
}
// System.Boolean UnityEngine.PhysicsScene::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
float V_0 = 0.0f;
bool V_1 = false;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_2;
memset((&V_2), 0, sizeof(V_2));
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 V_3;
memset((&V_3), 0, sizeof(V_3));
bool V_4 = false;
{
float L_0;
L_0 = Vector3_get_magnitude_mDDD40612220D8104E77E993E18A101A69A944991((Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction1), /*hidden argument*/NULL);
V_0 = L_0;
float L_1 = V_0;
V_1 = (bool)((((float)L_1) > ((float)(1.40129846E-45f)))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_003c;
}
}
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_3 = ___direction1;
float L_4 = V_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_5;
L_5 = Vector3_op_Division_mE5ACBFB168FED529587457A83BA98B7DB32E2A05_inline(L_3, L_4, /*hidden argument*/NULL);
V_2 = L_5;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_6 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_7 = V_2;
Ray__ctor_m75B1F651FF47EE6B887105101B7DA61CBF41F83C((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&V_3), L_6, L_7, /*hidden argument*/NULL);
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_8 = (*(PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)__this);
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 L_9 = V_3;
float L_10 = ___maxDistance2;
int32_t L_11 = ___layerMask3;
int32_t L_12 = ___queryTriggerInteraction4;
bool L_13;
L_13 = PhysicsScene_Internal_RaycastTest_m6715CAD8D0330195269AA7FCCD91613BC564E3EB(L_8, L_9, L_10, L_11, L_12, /*hidden argument*/NULL);
V_4 = L_13;
goto IL_0041;
}
IL_003c:
{
V_4 = (bool)0;
goto IL_0041;
}
IL_0041:
{
bool L_14 = V_4;
return L_14;
}
}
IL2CPP_EXTERN_C bool PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187_AdjustorThunk (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
int32_t _offset = 1;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * _thisAdjusted = reinterpret_cast<PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *>(__this + _offset);
bool _returnValue;
_returnValue = PhysicsScene_Raycast_m8C3E61EB7C3DB8AAC6FEB098D815062BEF821187(_thisAdjusted, ___origin0, ___direction1, ___maxDistance2, ___layerMask3, ___queryTriggerInteraction4, method);
return _returnValue;
}
// System.Boolean UnityEngine.PhysicsScene::Internal_RaycastTest(UnityEngine.PhysicsScene,UnityEngine.Ray,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Internal_RaycastTest_m6715CAD8D0330195269AA7FCCD91613BC564E3EB (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
{
float L_0 = ___maxDistance2;
int32_t L_1 = ___layerMask3;
int32_t L_2 = ___queryTriggerInteraction4;
bool L_3;
L_3 = PhysicsScene_Internal_RaycastTest_Injected_m956474EFEA507F82ABE0BCB75DDB3CC8EFF4D12B((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&___physicsScene0), (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray1), L_0, L_1, L_2, /*hidden argument*/NULL);
return L_3;
}
}
// System.Boolean UnityEngine.PhysicsScene::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
float V_0 = 0.0f;
bool V_1 = false;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_2;
memset((&V_2), 0, sizeof(V_2));
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 V_3;
memset((&V_3), 0, sizeof(V_3));
bool V_4 = false;
{
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_0 = ___hitInfo2;
il2cpp_codegen_initobj(L_0, sizeof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 ));
float L_1;
L_1 = Vector3_get_magnitude_mDDD40612220D8104E77E993E18A101A69A944991((Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction1), /*hidden argument*/NULL);
V_0 = L_1;
float L_2 = V_0;
V_1 = (bool)((((float)L_2) > ((float)(1.40129846E-45f)))? 1 : 0);
bool L_3 = V_1;
if (!L_3)
{
goto IL_0045;
}
}
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_4 = ___direction1;
float L_5 = V_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_6;
L_6 = Vector3_op_Division_mE5ACBFB168FED529587457A83BA98B7DB32E2A05_inline(L_4, L_5, /*hidden argument*/NULL);
V_2 = L_6;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_7 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_8 = V_2;
Ray__ctor_m75B1F651FF47EE6B887105101B7DA61CBF41F83C((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&V_3), L_7, L_8, /*hidden argument*/NULL);
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_9 = (*(PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)__this);
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 L_10 = V_3;
float L_11 = ___maxDistance3;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_12 = ___hitInfo2;
int32_t L_13 = ___layerMask4;
int32_t L_14 = ___queryTriggerInteraction5;
bool L_15;
L_15 = PhysicsScene_Internal_Raycast_m1E630AA11805114B090FC50741AEF64D677AF2C7(L_9, L_10, L_11, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_12, L_13, L_14, /*hidden argument*/NULL);
V_4 = L_15;
goto IL_004a;
}
IL_0045:
{
V_4 = (bool)0;
goto IL_004a;
}
IL_004a:
{
bool L_16 = V_4;
return L_16;
}
}
IL2CPP_EXTERN_C bool PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208_AdjustorThunk (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
int32_t _offset = 1;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * _thisAdjusted = reinterpret_cast<PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *>(__this + _offset);
bool _returnValue;
_returnValue = PhysicsScene_Raycast_mFC0D59C4439EE9DA6E8AA5F6891915132D587208(_thisAdjusted, ___origin0, ___direction1, ___hitInfo2, ___maxDistance3, ___layerMask4, ___queryTriggerInteraction5, method);
return _returnValue;
}
// System.Boolean UnityEngine.PhysicsScene::Internal_Raycast(UnityEngine.PhysicsScene,UnityEngine.Ray,System.Single,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Internal_Raycast_m1E630AA11805114B090FC50741AEF64D677AF2C7 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray1, float ___maxDistance2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hit3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
{
float L_0 = ___maxDistance2;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_1 = ___hit3;
int32_t L_2 = ___layerMask4;
int32_t L_3 = ___queryTriggerInteraction5;
bool L_4;
L_4 = PhysicsScene_Internal_Raycast_Injected_m8868E0BF89F8C42D11F42F94F9CF767647433BB1((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&___physicsScene0), (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray1), L_0, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_1, L_2, L_3, /*hidden argument*/NULL);
return L_4;
}
}
// System.Int32 UnityEngine.PhysicsScene::Raycast(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
float V_0 = 0.0f;
bool V_1 = false;
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 V_2;
memset((&V_2), 0, sizeof(V_2));
int32_t V_3 = 0;
{
float L_0;
L_0 = Vector3_get_magnitude_mDDD40612220D8104E77E993E18A101A69A944991((Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction1), /*hidden argument*/NULL);
V_0 = L_0;
float L_1 = V_0;
V_1 = (bool)((((float)L_1) > ((float)(1.40129846E-45f)))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_003b;
}
}
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_3 = ___origin0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_4;
L_4 = Vector3_get_normalized_m2FA6DF38F97BDA4CCBDAE12B9FE913A241DAC8D5((Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction1), /*hidden argument*/NULL);
Ray__ctor_m75B1F651FF47EE6B887105101B7DA61CBF41F83C((Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&V_2), L_3, L_4, /*hidden argument*/NULL);
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_5 = (*(PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)__this);
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 L_6 = V_2;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_7 = ___raycastHits2;
float L_8 = ___maxDistance3;
int32_t L_9 = ___layerMask4;
int32_t L_10 = ___queryTriggerInteraction5;
int32_t L_11;
L_11 = PhysicsScene_Internal_RaycastNonAlloc_mE7833EE5F1082431A4C2D29362F5DCDEFBF6D2BD(L_5, L_6, L_7, L_8, L_9, L_10, /*hidden argument*/NULL);
V_3 = L_11;
goto IL_003f;
}
IL_003b:
{
V_3 = 0;
goto IL_003f;
}
IL_003f:
{
int32_t L_12 = V_3;
return L_12;
}
}
IL2CPP_EXTERN_C int32_t PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73_AdjustorThunk (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits2, float ___maxDistance3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
int32_t _offset = 1;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * _thisAdjusted = reinterpret_cast<PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *>(__this + _offset);
int32_t _returnValue;
_returnValue = PhysicsScene_Raycast_m95CAB68EB9165E3AB2A4D441F7DF9767AD4B7F73(_thisAdjusted, ___origin0, ___direction1, ___raycastHits2, ___maxDistance3, ___layerMask4, ___queryTriggerInteraction5, method);
return _returnValue;
}
// System.Int32 UnityEngine.PhysicsScene::Internal_RaycastNonAlloc(UnityEngine.PhysicsScene,UnityEngine.Ray,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_Internal_RaycastNonAlloc_mE7833EE5F1082431A4C2D29362F5DCDEFBF6D2BD (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___ray1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits2, float ___maxDistance3, int32_t ___mask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
{
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_0 = ___raycastHits2;
float L_1 = ___maxDistance3;
int32_t L_2 = ___mask4;
int32_t L_3 = ___queryTriggerInteraction5;
int32_t L_4;
L_4 = PhysicsScene_Internal_RaycastNonAlloc_Injected_m59FB44C18E62D21E9320F30229C0AA9F9B971211((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&___physicsScene0), (Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *)(&___ray1), L_0, L_1, L_2, L_3, /*hidden argument*/NULL);
return L_4;
}
}
// System.Boolean UnityEngine.PhysicsScene::Query_SphereCast(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,UnityEngine.Vector3,System.Single,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Query_SphereCast_m47352512958CE213DD034AE53DB2E0C0247A38C3 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction3, float ___maxDistance4, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo5, int32_t ___layerMask6, int32_t ___queryTriggerInteraction7, const RuntimeMethod* method)
{
{
float L_0 = ___radius2;
float L_1 = ___maxDistance4;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_2 = ___hitInfo5;
int32_t L_3 = ___layerMask6;
int32_t L_4 = ___queryTriggerInteraction7;
bool L_5;
L_5 = PhysicsScene_Query_SphereCast_Injected_m6DD8E497811A3098113F5E9F52D7B0CAE63DC1EB((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&___physicsScene0), (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___origin1), L_0, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction3), L_1, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_2, L_3, L_4, /*hidden argument*/NULL);
return L_5;
}
}
// System.Boolean UnityEngine.PhysicsScene::Internal_SphereCast(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Internal_SphereCast_mFEE43A5306A097D0D2CB389A200921320130E55B (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction3, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo4, float ___maxDistance5, int32_t ___layerMask6, int32_t ___queryTriggerInteraction7, const RuntimeMethod* method)
{
float V_0 = 0.0f;
bool V_1 = false;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_2;
memset((&V_2), 0, sizeof(V_2));
bool V_3 = false;
{
float L_0;
L_0 = Vector3_get_magnitude_mDDD40612220D8104E77E993E18A101A69A944991((Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction3), /*hidden argument*/NULL);
V_0 = L_0;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_1 = ___hitInfo4;
il2cpp_codegen_initobj(L_1, sizeof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 ));
float L_2 = V_0;
V_1 = (bool)((((float)L_2) > ((float)(1.40129846E-45f)))? 1 : 0);
bool L_3 = V_1;
if (!L_3)
{
goto IL_003a;
}
}
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_4 = ___direction3;
float L_5 = V_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_6;
L_6 = Vector3_op_Division_mE5ACBFB168FED529587457A83BA98B7DB32E2A05_inline(L_4, L_5, /*hidden argument*/NULL);
V_2 = L_6;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_7 = ___physicsScene0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_8 = ___origin1;
float L_9 = ___radius2;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_10 = V_2;
float L_11 = ___maxDistance5;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_12 = ___hitInfo4;
int32_t L_13 = ___layerMask6;
int32_t L_14 = ___queryTriggerInteraction7;
bool L_15;
L_15 = PhysicsScene_Query_SphereCast_m47352512958CE213DD034AE53DB2E0C0247A38C3(L_7, L_8, L_9, L_10, L_11, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_12, L_13, L_14, /*hidden argument*/NULL);
V_3 = L_15;
goto IL_003e;
}
IL_003a:
{
V_3 = (bool)0;
goto IL_003e;
}
IL_003e:
{
bool L_16 = V_3;
return L_16;
}
}
// System.Boolean UnityEngine.PhysicsScene::SphereCast(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_SphereCast_m72928994362EE11F9A4F72BD79954444B9FD1C2D (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo3, float ___maxDistance4, int32_t ___layerMask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method)
{
bool V_0 = false;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0 = (*(PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)__this);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___origin0;
float L_2 = ___radius1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_3 = ___direction2;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * L_4 = ___hitInfo3;
float L_5 = ___maxDistance4;
int32_t L_6 = ___layerMask5;
int32_t L_7 = ___queryTriggerInteraction6;
bool L_8;
L_8 = PhysicsScene_Internal_SphereCast_mFEE43A5306A097D0D2CB389A200921320130E55B(L_0, L_1, L_2, L_3, (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)L_4, L_5, L_6, L_7, /*hidden argument*/NULL);
V_0 = L_8;
goto IL_001a;
}
IL_001a:
{
bool L_9 = V_0;
return L_9;
}
}
IL2CPP_EXTERN_C bool PhysicsScene_SphereCast_m72928994362EE11F9A4F72BD79954444B9FD1C2D_AdjustorThunk (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo3, float ___maxDistance4, int32_t ___layerMask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method)
{
int32_t _offset = 1;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * _thisAdjusted = reinterpret_cast<PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *>(__this + _offset);
bool _returnValue;
_returnValue = PhysicsScene_SphereCast_m72928994362EE11F9A4F72BD79954444B9FD1C2D(_thisAdjusted, ___origin0, ___radius1, ___direction2, ___hitInfo3, ___maxDistance4, ___layerMask5, ___queryTriggerInteraction6, method);
return _returnValue;
}
// System.Int32 UnityEngine.PhysicsScene::Internal_SphereCastNonAlloc(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_Internal_SphereCastNonAlloc_mB8513F888165C580ED47D021D1A0832A0175098A (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction3, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits4, float ___maxDistance5, int32_t ___mask6, int32_t ___queryTriggerInteraction7, const RuntimeMethod* method)
{
{
float L_0 = ___radius2;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_1 = ___raycastHits4;
float L_2 = ___maxDistance5;
int32_t L_3 = ___mask6;
int32_t L_4 = ___queryTriggerInteraction7;
int32_t L_5;
L_5 = PhysicsScene_Internal_SphereCastNonAlloc_Injected_m4F9D87DA90995ECD2AD86314F57231722EE2C894((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&___physicsScene0), (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___origin1), L_0, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction3), L_1, L_2, L_3, L_4, /*hidden argument*/NULL);
return L_5;
}
}
// System.Int32 UnityEngine.PhysicsScene::SphereCast(UnityEngine.Vector3,System.Single,UnityEngine.Vector3,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_SphereCast_m36723F888676E712CC40A0E54D72E95F73D193D3 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results3, float ___maxDistance4, int32_t ___layerMask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method)
{
float V_0 = 0.0f;
bool V_1 = false;
int32_t V_2 = 0;
{
float L_0;
L_0 = Vector3_get_magnitude_mDDD40612220D8104E77E993E18A101A69A944991((Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___direction2), /*hidden argument*/NULL);
V_0 = L_0;
float L_1 = V_0;
V_1 = (bool)((((float)L_1) > ((float)(1.40129846E-45f)))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_002f;
}
}
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_3 = (*(PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)__this);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_4 = ___origin0;
float L_5 = ___radius1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_6 = ___direction2;
RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* L_7 = ___results3;
float L_8 = ___maxDistance4;
int32_t L_9 = ___layerMask5;
int32_t L_10 = ___queryTriggerInteraction6;
int32_t L_11;
L_11 = PhysicsScene_Internal_SphereCastNonAlloc_mB8513F888165C580ED47D021D1A0832A0175098A(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, /*hidden argument*/NULL);
V_2 = L_11;
goto IL_0034;
}
IL_002f:
{
V_2 = 0;
goto IL_0034;
}
IL_0034:
{
int32_t L_12 = V_2;
return L_12;
}
}
IL2CPP_EXTERN_C int32_t PhysicsScene_SphereCast_m36723F888676E712CC40A0E54D72E95F73D193D3_AdjustorThunk (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___origin0, float ___radius1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___direction2, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___results3, float ___maxDistance4, int32_t ___layerMask5, int32_t ___queryTriggerInteraction6, const RuntimeMethod* method)
{
int32_t _offset = 1;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * _thisAdjusted = reinterpret_cast<PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *>(__this + _offset);
int32_t _returnValue;
_returnValue = PhysicsScene_SphereCast_m36723F888676E712CC40A0E54D72E95F73D193D3(_thisAdjusted, ___origin0, ___radius1, ___direction2, ___results3, ___maxDistance4, ___layerMask5, ___queryTriggerInteraction6, method);
return _returnValue;
}
// System.Int32 UnityEngine.PhysicsScene::OverlapSphereNonAlloc_Internal(UnityEngine.PhysicsScene,UnityEngine.Vector3,System.Single,UnityEngine.Collider[],System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_OverlapSphereNonAlloc_Internal_m164D02A6A67B8CB8E1CAEDE56AD48CC0042435D7 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position1, float ___radius2, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* ___results3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
{
float L_0 = ___radius2;
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* L_1 = ___results3;
int32_t L_2 = ___layerMask4;
int32_t L_3 = ___queryTriggerInteraction5;
int32_t L_4;
L_4 = PhysicsScene_OverlapSphereNonAlloc_Internal_Injected_mFD0BF0E38E9E17D7AB571531EDC7F181CF4BEFB3((PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)(&___physicsScene0), (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___position1), L_0, L_1, L_2, L_3, /*hidden argument*/NULL);
return L_4;
}
}
// System.Int32 UnityEngine.PhysicsScene::OverlapSphere(UnityEngine.Vector3,System.Single,UnityEngine.Collider[],System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_OverlapSphere_mBFBB0C810534D52967EE4FDC97DB67301D769ACC (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, float ___radius1, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* ___results2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 L_0 = (*(PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *)__this);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___position0;
float L_2 = ___radius1;
ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* L_3 = ___results2;
int32_t L_4 = ___layerMask3;
int32_t L_5 = ___queryTriggerInteraction4;
int32_t L_6;
L_6 = PhysicsScene_OverlapSphereNonAlloc_Internal_m164D02A6A67B8CB8E1CAEDE56AD48CC0042435D7(L_0, L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
V_0 = L_6;
goto IL_0016;
}
IL_0016:
{
int32_t L_7 = V_0;
return L_7;
}
}
IL2CPP_EXTERN_C int32_t PhysicsScene_OverlapSphere_mBFBB0C810534D52967EE4FDC97DB67301D769ACC_AdjustorThunk (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, float ___radius1, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* ___results2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
int32_t _offset = 1;
PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * _thisAdjusted = reinterpret_cast<PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *>(__this + _offset);
int32_t _returnValue;
_returnValue = PhysicsScene_OverlapSphere_mBFBB0C810534D52967EE4FDC97DB67301D769ACC(_thisAdjusted, ___position0, ___radius1, ___results2, ___layerMask3, ___queryTriggerInteraction4, method);
return _returnValue;
}
// System.Boolean UnityEngine.PhysicsScene::Internal_RaycastTest_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Internal_RaycastTest_Injected_m956474EFEA507F82ABE0BCB75DDB3CC8EFF4D12B (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * ___ray1, float ___maxDistance2, int32_t ___layerMask3, int32_t ___queryTriggerInteraction4, const RuntimeMethod* method)
{
typedef bool (*PhysicsScene_Internal_RaycastTest_Injected_m956474EFEA507F82ABE0BCB75DDB3CC8EFF4D12B_ftn) (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *, float, int32_t, int32_t);
static PhysicsScene_Internal_RaycastTest_Injected_m956474EFEA507F82ABE0BCB75DDB3CC8EFF4D12B_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (PhysicsScene_Internal_RaycastTest_Injected_m956474EFEA507F82ABE0BCB75DDB3CC8EFF4D12B_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.PhysicsScene::Internal_RaycastTest_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)");
bool icallRetVal = _il2cpp_icall_func(___physicsScene0, ___ray1, ___maxDistance2, ___layerMask3, ___queryTriggerInteraction4);
return icallRetVal;
}
// System.Boolean UnityEngine.PhysicsScene::Internal_Raycast_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,System.Single,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Internal_Raycast_Injected_m8868E0BF89F8C42D11F42F94F9CF767647433BB1 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * ___ray1, float ___maxDistance2, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hit3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
typedef bool (*PhysicsScene_Internal_Raycast_Injected_m8868E0BF89F8C42D11F42F94F9CF767647433BB1_ftn) (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *, float, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *, int32_t, int32_t);
static PhysicsScene_Internal_Raycast_Injected_m8868E0BF89F8C42D11F42F94F9CF767647433BB1_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (PhysicsScene_Internal_Raycast_Injected_m8868E0BF89F8C42D11F42F94F9CF767647433BB1_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.PhysicsScene::Internal_Raycast_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,System.Single,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)");
bool icallRetVal = _il2cpp_icall_func(___physicsScene0, ___ray1, ___maxDistance2, ___hit3, ___layerMask4, ___queryTriggerInteraction5);
return icallRetVal;
}
// System.Int32 UnityEngine.PhysicsScene::Internal_RaycastNonAlloc_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_Internal_RaycastNonAlloc_Injected_m59FB44C18E62D21E9320F30229C0AA9F9B971211 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * ___ray1, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits2, float ___maxDistance3, int32_t ___mask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
typedef int32_t (*PhysicsScene_Internal_RaycastNonAlloc_Injected_m59FB44C18E62D21E9320F30229C0AA9F9B971211_ftn) (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 *, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09*, float, int32_t, int32_t);
static PhysicsScene_Internal_RaycastNonAlloc_Injected_m59FB44C18E62D21E9320F30229C0AA9F9B971211_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (PhysicsScene_Internal_RaycastNonAlloc_Injected_m59FB44C18E62D21E9320F30229C0AA9F9B971211_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.PhysicsScene::Internal_RaycastNonAlloc_Injected(UnityEngine.PhysicsScene&,UnityEngine.Ray&,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)");
int32_t icallRetVal = _il2cpp_icall_func(___physicsScene0, ___ray1, ___raycastHits2, ___maxDistance3, ___mask4, ___queryTriggerInteraction5);
return icallRetVal;
}
// System.Boolean UnityEngine.PhysicsScene::Query_SphereCast_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Vector3&,System.Single,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool PhysicsScene_Query_SphereCast_Injected_m6DD8E497811A3098113F5E9F52D7B0CAE63DC1EB (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction3, float ___maxDistance4, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * ___hitInfo5, int32_t ___layerMask6, int32_t ___queryTriggerInteraction7, const RuntimeMethod* method)
{
typedef bool (*PhysicsScene_Query_SphereCast_Injected_m6DD8E497811A3098113F5E9F52D7B0CAE63DC1EB_ftn) (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, float, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, float, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *, int32_t, int32_t);
static PhysicsScene_Query_SphereCast_Injected_m6DD8E497811A3098113F5E9F52D7B0CAE63DC1EB_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (PhysicsScene_Query_SphereCast_Injected_m6DD8E497811A3098113F5E9F52D7B0CAE63DC1EB_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.PhysicsScene::Query_SphereCast_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Vector3&,System.Single,UnityEngine.RaycastHit&,System.Int32,UnityEngine.QueryTriggerInteraction)");
bool icallRetVal = _il2cpp_icall_func(___physicsScene0, ___origin1, ___radius2, ___direction3, ___maxDistance4, ___hitInfo5, ___layerMask6, ___queryTriggerInteraction7);
return icallRetVal;
}
// System.Int32 UnityEngine.PhysicsScene::Internal_SphereCastNonAlloc_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Vector3&,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_Internal_SphereCastNonAlloc_Injected_m4F9D87DA90995ECD2AD86314F57231722EE2C894 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___origin1, float ___radius2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___direction3, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09* ___raycastHits4, float ___maxDistance5, int32_t ___mask6, int32_t ___queryTriggerInteraction7, const RuntimeMethod* method)
{
typedef int32_t (*PhysicsScene_Internal_SphereCastNonAlloc_Injected_m4F9D87DA90995ECD2AD86314F57231722EE2C894_ftn) (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, float, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, RaycastHitU5BU5D_t6778DB95346906446AAD3A1A36904F1846435A09*, float, int32_t, int32_t);
static PhysicsScene_Internal_SphereCastNonAlloc_Injected_m4F9D87DA90995ECD2AD86314F57231722EE2C894_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (PhysicsScene_Internal_SphereCastNonAlloc_Injected_m4F9D87DA90995ECD2AD86314F57231722EE2C894_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.PhysicsScene::Internal_SphereCastNonAlloc_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Vector3&,UnityEngine.RaycastHit[],System.Single,System.Int32,UnityEngine.QueryTriggerInteraction)");
int32_t icallRetVal = _il2cpp_icall_func(___physicsScene0, ___origin1, ___radius2, ___direction3, ___raycastHits4, ___maxDistance5, ___mask6, ___queryTriggerInteraction7);
return icallRetVal;
}
// System.Int32 UnityEngine.PhysicsScene::OverlapSphereNonAlloc_Internal_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Collider[],System.Int32,UnityEngine.QueryTriggerInteraction)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t PhysicsScene_OverlapSphereNonAlloc_Internal_Injected_mFD0BF0E38E9E17D7AB571531EDC7F181CF4BEFB3 (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 * ___physicsScene0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___position1, float ___radius2, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486* ___results3, int32_t ___layerMask4, int32_t ___queryTriggerInteraction5, const RuntimeMethod* method)
{
typedef int32_t (*PhysicsScene_OverlapSphereNonAlloc_Internal_Injected_mFD0BF0E38E9E17D7AB571531EDC7F181CF4BEFB3_ftn) (PhysicsScene_tEDFCAA935450E8EBB7732353D9AA264A5F711678 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, float, ColliderU5BU5D_t5124940293343DB3D31DA41C593709905906E486*, int32_t, int32_t);
static PhysicsScene_OverlapSphereNonAlloc_Internal_Injected_mFD0BF0E38E9E17D7AB571531EDC7F181CF4BEFB3_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (PhysicsScene_OverlapSphereNonAlloc_Internal_Injected_mFD0BF0E38E9E17D7AB571531EDC7F181CF4BEFB3_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.PhysicsScene::OverlapSphereNonAlloc_Internal_Injected(UnityEngine.PhysicsScene&,UnityEngine.Vector3&,System.Single,UnityEngine.Collider[],System.Int32,UnityEngine.QueryTriggerInteraction)");
int32_t icallRetVal = _il2cpp_icall_func(___physicsScene0, ___position1, ___radius2, ___results3, ___layerMask4, ___queryTriggerInteraction5);
return icallRetVal;
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Collider UnityEngine.RaycastHit::get_collider()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * V_0 = NULL;
{
int32_t L_0 = __this->get_m_Collider_5();
IL2CPP_RUNTIME_CLASS_INIT(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
Object_tF2F3778131EFF286AF62B7B013A170F95A91571A * L_1;
L_1 = Object_FindObjectFromInstanceID_m0AD731D3F583CBBDC7DC0E08B38F742B447FA44A(L_0, /*hidden argument*/NULL);
V_0 = ((Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *)IsInstClass((RuntimeObject*)L_1, Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02_il2cpp_TypeInfo_var));
goto IL_0014;
}
IL_0014:
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_2 = V_0;
return L_2;
}
}
IL2CPP_EXTERN_C Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * _returnValue;
_returnValue = RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E(_thisAdjusted, method);
return _returnValue;
}
// UnityEngine.Vector3 UnityEngine.RaycastHit::get_point()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E RaycastHit_get_point_m32F7282CBB2E13393A33BAD046BDA218E48DD21E (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = __this->get_m_Point_0();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = V_0;
return L_1;
}
}
IL2CPP_EXTERN_C Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E RaycastHit_get_point_m32F7282CBB2E13393A33BAD046BDA218E48DD21E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E _returnValue;
_returnValue = RaycastHit_get_point_m32F7282CBB2E13393A33BAD046BDA218E48DD21E(_thisAdjusted, method);
return _returnValue;
}
// System.Void UnityEngine.RaycastHit::set_point(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RaycastHit_set_point_mBB4D9069F8DB5BA15E31DBA68AB68789687FA88F (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___value0;
__this->set_m_Point_0(L_0);
return;
}
}
IL2CPP_EXTERN_C void RaycastHit_set_point_mBB4D9069F8DB5BA15E31DBA68AB68789687FA88F_AdjustorThunk (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
RaycastHit_set_point_mBB4D9069F8DB5BA15E31DBA68AB68789687FA88F(_thisAdjusted, ___value0, method);
}
// UnityEngine.Vector3 UnityEngine.RaycastHit::get_normal()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E RaycastHit_get_normal_m2C813B25BAECD87FD9E9CB294278B291F4CC6674 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = __this->get_m_Normal_1();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = V_0;
return L_1;
}
}
IL2CPP_EXTERN_C Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E RaycastHit_get_normal_m2C813B25BAECD87FD9E9CB294278B291F4CC6674_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E _returnValue;
_returnValue = RaycastHit_get_normal_m2C813B25BAECD87FD9E9CB294278B291F4CC6674(_thisAdjusted, method);
return _returnValue;
}
// System.Void UnityEngine.RaycastHit::set_normal(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RaycastHit_set_normal_mAD9EEA4720F62D7286E9EAE8F26753352EFF9270 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___value0;
__this->set_m_Normal_1(L_0);
return;
}
}
IL2CPP_EXTERN_C void RaycastHit_set_normal_mAD9EEA4720F62D7286E9EAE8F26753352EFF9270_AdjustorThunk (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
RaycastHit_set_normal_mAD9EEA4720F62D7286E9EAE8F26753352EFF9270(_thisAdjusted, ___value0, method);
}
// UnityEngine.Vector3 UnityEngine.RaycastHit::get_barycentricCoordinate()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E RaycastHit_get_barycentricCoordinate_mF5FE7CE94A15D9FB47C617CC62CD7C4E785F6B91 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * L_0 = __this->get_address_of_m_UV_4();
float L_1 = L_0->get_y_1();
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * L_2 = __this->get_address_of_m_UV_4();
float L_3 = L_2->get_x_0();
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * L_4 = __this->get_address_of_m_UV_4();
float L_5 = L_4->get_x_0();
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * L_6 = __this->get_address_of_m_UV_4();
float L_7 = L_6->get_y_1();
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_8;
memset((&L_8), 0, sizeof(L_8));
Vector3__ctor_m57495F692C6CE1CEF278CAD9A98221165D37E636_inline((&L_8), ((float)il2cpp_codegen_subtract((float)(1.0f), (float)((float)il2cpp_codegen_add((float)L_1, (float)L_3)))), L_5, L_7, /*hidden argument*/NULL);
V_0 = L_8;
goto IL_003c;
}
IL_003c:
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_9 = V_0;
return L_9;
}
}
IL2CPP_EXTERN_C Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E RaycastHit_get_barycentricCoordinate_mF5FE7CE94A15D9FB47C617CC62CD7C4E785F6B91_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E _returnValue;
_returnValue = RaycastHit_get_barycentricCoordinate_mF5FE7CE94A15D9FB47C617CC62CD7C4E785F6B91(_thisAdjusted, method);
return _returnValue;
}
// System.Single UnityEngine.RaycastHit::get_distance()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float RaycastHit_get_distance_m85FCA98D7957C3BF1D449CA1B48C116CCD6226FA (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_Distance_3();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
float L_1 = V_0;
return L_1;
}
}
IL2CPP_EXTERN_C float RaycastHit_get_distance_m85FCA98D7957C3BF1D449CA1B48C116CCD6226FA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
float _returnValue;
_returnValue = RaycastHit_get_distance_m85FCA98D7957C3BF1D449CA1B48C116CCD6226FA(_thisAdjusted, method);
return _returnValue;
}
// System.Void UnityEngine.RaycastHit::set_distance(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RaycastHit_set_distance_m287DCD9DAE1D3AE76C7C4DE2F192E4DFBA911F41 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, float ___value0, const RuntimeMethod* method)
{
{
float L_0 = ___value0;
__this->set_m_Distance_3(L_0);
return;
}
}
IL2CPP_EXTERN_C void RaycastHit_set_distance_m287DCD9DAE1D3AE76C7C4DE2F192E4DFBA911F41_AdjustorThunk (RuntimeObject * __this, float ___value0, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
RaycastHit_set_distance_m287DCD9DAE1D3AE76C7C4DE2F192E4DFBA911F41(_thisAdjusted, ___value0, method);
}
// System.Int32 UnityEngine.RaycastHit::get_triangleIndex()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t RaycastHit_get_triangleIndex_mC9FE4EB1B57D5EAFB3B116F4FD3332ADC50E5538 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
uint32_t L_0 = __this->get_m_FaceID_2();
V_0 = L_0;
goto IL_000a;
}
IL_000a:
{
int32_t L_1 = V_0;
return L_1;
}
}
IL2CPP_EXTERN_C int32_t RaycastHit_get_triangleIndex_mC9FE4EB1B57D5EAFB3B116F4FD3332ADC50E5538_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
int32_t _returnValue;
_returnValue = RaycastHit_get_triangleIndex_mC9FE4EB1B57D5EAFB3B116F4FD3332ADC50E5538(_thisAdjusted, method);
return _returnValue;
}
// UnityEngine.Vector2 UnityEngine.RaycastHit::CalculateRaycastTexCoord(UnityEngine.Collider,UnityEngine.Vector2,UnityEngine.Vector3,System.UInt32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_CalculateRaycastTexCoord_mA0C4A5964A2CC5EE35AD330FCF15B37D85827554 (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider0, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___uv1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___pos2, uint32_t ___face3, int32_t ___textcoord4, const RuntimeMethod* method)
{
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 V_0;
memset((&V_0), 0, sizeof(V_0));
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_0 = ___collider0;
uint32_t L_1 = ___face3;
int32_t L_2 = ___textcoord4;
RaycastHit_CalculateRaycastTexCoord_Injected_m1FF45C3E7C9706065ED99031A70BDD8F7F8202CE(L_0, (Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 *)(&___uv1), (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___pos2), L_1, L_2, (Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 *)(&V_0), /*hidden argument*/NULL);
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_3 = V_0;
return L_3;
}
}
// UnityEngine.Vector2 UnityEngine.RaycastHit::get_textureCoord()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_get_textureCoord_m14246DFF0F641326DFE9CFDCD326F727A3EE3777 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 V_0;
memset((&V_0), 0, sizeof(V_0));
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_0;
L_0 = RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E((RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)__this, /*hidden argument*/NULL);
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_1 = __this->get_m_UV_4();
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = __this->get_m_Point_0();
uint32_t L_3 = __this->get_m_FaceID_2();
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_4;
L_4 = RaycastHit_CalculateRaycastTexCoord_mA0C4A5964A2CC5EE35AD330FCF15B37D85827554(L_0, L_1, L_2, L_3, 0, /*hidden argument*/NULL);
V_0 = L_4;
goto IL_0022;
}
IL_0022:
{
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_5 = V_0;
return L_5;
}
}
IL2CPP_EXTERN_C Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_get_textureCoord_m14246DFF0F641326DFE9CFDCD326F727A3EE3777_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 _returnValue;
_returnValue = RaycastHit_get_textureCoord_m14246DFF0F641326DFE9CFDCD326F727A3EE3777(_thisAdjusted, method);
return _returnValue;
}
// UnityEngine.Vector2 UnityEngine.RaycastHit::get_textureCoord2()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_get_textureCoord2_m93EA616280855F963876CD677D94AF857DAE9E57 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 V_0;
memset((&V_0), 0, sizeof(V_0));
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_0;
L_0 = RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E((RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)__this, /*hidden argument*/NULL);
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_1 = __this->get_m_UV_4();
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = __this->get_m_Point_0();
uint32_t L_3 = __this->get_m_FaceID_2();
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_4;
L_4 = RaycastHit_CalculateRaycastTexCoord_mA0C4A5964A2CC5EE35AD330FCF15B37D85827554(L_0, L_1, L_2, L_3, 1, /*hidden argument*/NULL);
V_0 = L_4;
goto IL_0022;
}
IL_0022:
{
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_5 = V_0;
return L_5;
}
}
IL2CPP_EXTERN_C Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_get_textureCoord2_m93EA616280855F963876CD677D94AF857DAE9E57_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 _returnValue;
_returnValue = RaycastHit_get_textureCoord2_m93EA616280855F963876CD677D94AF857DAE9E57(_thisAdjusted, method);
return _returnValue;
}
// UnityEngine.Transform UnityEngine.RaycastHit::get_transform()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * RaycastHit_get_transform_m2DD983DBD3602DE848DE287EE5233FD02EEC608D (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * V_0 = NULL;
bool V_1 = false;
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * V_2 = NULL;
bool V_3 = false;
{
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * L_0;
L_0 = RaycastHit_get_rigidbody_mE48E45893FDAFD03162C6A73AAF02C6CB0E079FB((RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)__this, /*hidden argument*/NULL);
V_0 = L_0;
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * L_1 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
bool L_2;
L_2 = Object_op_Inequality_mE1F187520BD83FB7D86A6D850710C4D42B864E90(L_1, (Object_tF2F3778131EFF286AF62B7B013A170F95A91571A *)NULL, /*hidden argument*/NULL);
V_1 = L_2;
bool L_3 = V_1;
if (!L_3)
{
goto IL_001c;
}
}
{
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * L_4 = V_0;
NullCheck(L_4);
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * L_5;
L_5 = Component_get_transform_mE8496EBC45BEB1BADB5F314960F1DF1C952FA11F(L_4, /*hidden argument*/NULL);
V_2 = L_5;
goto IL_003e;
}
IL_001c:
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_6;
L_6 = RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E((RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)__this, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
bool L_7;
L_7 = Object_op_Inequality_mE1F187520BD83FB7D86A6D850710C4D42B864E90(L_6, (Object_tF2F3778131EFF286AF62B7B013A170F95A91571A *)NULL, /*hidden argument*/NULL);
V_3 = L_7;
bool L_8 = V_3;
if (!L_8)
{
goto IL_003a;
}
}
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_9;
L_9 = RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E((RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)__this, /*hidden argument*/NULL);
NullCheck(L_9);
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * L_10;
L_10 = Component_get_transform_mE8496EBC45BEB1BADB5F314960F1DF1C952FA11F(L_9, /*hidden argument*/NULL);
V_2 = L_10;
goto IL_003e;
}
IL_003a:
{
V_2 = (Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 *)NULL;
goto IL_003e;
}
IL_003e:
{
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * L_11 = V_2;
return L_11;
}
}
IL2CPP_EXTERN_C Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * RaycastHit_get_transform_m2DD983DBD3602DE848DE287EE5233FD02EEC608D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * _returnValue;
_returnValue = RaycastHit_get_transform_m2DD983DBD3602DE848DE287EE5233FD02EEC608D(_thisAdjusted, method);
return _returnValue;
}
// UnityEngine.Rigidbody UnityEngine.RaycastHit::get_rigidbody()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * RaycastHit_get_rigidbody_mE48E45893FDAFD03162C6A73AAF02C6CB0E079FB (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * V_0 = NULL;
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * G_B3_0 = NULL;
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_0;
L_0 = RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E((RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)__this, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
bool L_1;
L_1 = Object_op_Inequality_mE1F187520BD83FB7D86A6D850710C4D42B864E90(L_0, (Object_tF2F3778131EFF286AF62B7B013A170F95A91571A *)NULL, /*hidden argument*/NULL);
if (L_1)
{
goto IL_0012;
}
}
{
G_B3_0 = ((Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *)(NULL));
goto IL_001d;
}
IL_0012:
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_2;
L_2 = RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E((RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)__this, /*hidden argument*/NULL);
NullCheck(L_2);
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * L_3;
L_3 = Collider_get_attachedRigidbody_m101FED12AD292F372F98E94A6D02A5E428AA896A(L_2, /*hidden argument*/NULL);
G_B3_0 = L_3;
}
IL_001d:
{
V_0 = G_B3_0;
goto IL_0020;
}
IL_0020:
{
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * L_4 = V_0;
return L_4;
}
}
IL2CPP_EXTERN_C Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * RaycastHit_get_rigidbody_mE48E45893FDAFD03162C6A73AAF02C6CB0E079FB_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * _returnValue;
_returnValue = RaycastHit_get_rigidbody_mE48E45893FDAFD03162C6A73AAF02C6CB0E079FB(_thisAdjusted, method);
return _returnValue;
}
// UnityEngine.Vector2 UnityEngine.RaycastHit::get_lightmapCoord()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_get_lightmapCoord_mAD5C7DFC562B22AC97DC2573C34C8BB364676FD9 (RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Component_GetComponent_TisRenderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C_m436E5B0F17DDEF3CC61F77DEA82B1A92668AF019_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 V_2;
memset((&V_2), 0, sizeof(V_2));
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 V_3;
memset((&V_3), 0, sizeof(V_3));
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_0;
L_0 = RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E((RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)__this, /*hidden argument*/NULL);
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_1 = __this->get_m_UV_4();
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = __this->get_m_Point_0();
uint32_t L_3 = __this->get_m_FaceID_2();
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_4;
L_4 = RaycastHit_CalculateRaycastTexCoord_mA0C4A5964A2CC5EE35AD330FCF15B37D85827554(L_0, L_1, L_2, L_3, 1, /*hidden argument*/NULL);
V_0 = L_4;
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_5;
L_5 = RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E((RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)__this, /*hidden argument*/NULL);
NullCheck(L_5);
Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C * L_6;
L_6 = Component_GetComponent_TisRenderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C_m436E5B0F17DDEF3CC61F77DEA82B1A92668AF019(L_5, /*hidden argument*/Component_GetComponent_TisRenderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C_m436E5B0F17DDEF3CC61F77DEA82B1A92668AF019_RuntimeMethod_var);
IL2CPP_RUNTIME_CLASS_INIT(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_il2cpp_TypeInfo_var);
bool L_7;
L_7 = Object_op_Inequality_mE1F187520BD83FB7D86A6D850710C4D42B864E90(L_6, (Object_tF2F3778131EFF286AF62B7B013A170F95A91571A *)NULL, /*hidden argument*/NULL);
V_1 = L_7;
bool L_8 = V_1;
if (!L_8)
{
goto IL_007e;
}
}
{
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * L_9;
L_9 = RaycastHit_get_collider_m13A3DE16FBC631E0A1F987E0B22CE70AF8AB539E((RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *)__this, /*hidden argument*/NULL);
NullCheck(L_9);
Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C * L_10;
L_10 = Component_GetComponent_TisRenderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C_m436E5B0F17DDEF3CC61F77DEA82B1A92668AF019(L_9, /*hidden argument*/Component_GetComponent_TisRenderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C_m436E5B0F17DDEF3CC61F77DEA82B1A92668AF019_RuntimeMethod_var);
NullCheck(L_10);
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 L_11;
L_11 = Renderer_get_lightmapScaleOffset_mB2A11E1B4F8F34DBC7F95165AC5EAB80553E2A62(L_10, /*hidden argument*/NULL);
V_2 = L_11;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_12 = V_0;
float L_13 = L_12.get_x_0();
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 L_14 = V_2;
float L_15 = L_14.get_x_1();
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 L_16 = V_2;
float L_17 = L_16.get_z_3();
(&V_0)->set_x_0(((float)il2cpp_codegen_add((float)((float)il2cpp_codegen_multiply((float)L_13, (float)L_15)), (float)L_17)));
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_18 = V_0;
float L_19 = L_18.get_y_1();
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 L_20 = V_2;
float L_21 = L_20.get_y_2();
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 L_22 = V_2;
float L_23 = L_22.get_w_4();
(&V_0)->set_y_1(((float)il2cpp_codegen_add((float)((float)il2cpp_codegen_multiply((float)L_19, (float)L_21)), (float)L_23)));
}
IL_007e:
{
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_24 = V_0;
V_3 = L_24;
goto IL_0082;
}
IL_0082:
{
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 L_25 = V_3;
return L_25;
}
}
IL2CPP_EXTERN_C Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 RaycastHit_get_lightmapCoord_mAD5C7DFC562B22AC97DC2573C34C8BB364676FD9_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 * _thisAdjusted = reinterpret_cast<RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 *>(__this + _offset);
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 _returnValue;
_returnValue = RaycastHit_get_lightmapCoord_mAD5C7DFC562B22AC97DC2573C34C8BB364676FD9(_thisAdjusted, method);
return _returnValue;
}
// System.Void UnityEngine.RaycastHit::CalculateRaycastTexCoord_Injected(UnityEngine.Collider,UnityEngine.Vector2&,UnityEngine.Vector3&,System.UInt32,System.Int32,UnityEngine.Vector2&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RaycastHit_CalculateRaycastTexCoord_Injected_m1FF45C3E7C9706065ED99031A70BDD8F7F8202CE (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider0, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * ___uv1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___pos2, uint32_t ___face3, int32_t ___textcoord4, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * ___ret5, const RuntimeMethod* method)
{
typedef void (*RaycastHit_CalculateRaycastTexCoord_Injected_m1FF45C3E7C9706065ED99031A70BDD8F7F8202CE_ftn) (Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 *, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, uint32_t, int32_t, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 *);
static RaycastHit_CalculateRaycastTexCoord_Injected_m1FF45C3E7C9706065ED99031A70BDD8F7F8202CE_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RaycastHit_CalculateRaycastTexCoord_Injected_m1FF45C3E7C9706065ED99031A70BDD8F7F8202CE_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RaycastHit::CalculateRaycastTexCoord_Injected(UnityEngine.Collider,UnityEngine.Vector2&,UnityEngine.Vector3&,System.UInt32,System.Int32,UnityEngine.Vector2&)");
_il2cpp_icall_func(___collider0, ___uv1, ___pos2, ___face3, ___textcoord4, ___ret5);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector3 UnityEngine.Rigidbody::get_velocity()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Rigidbody_get_velocity_mCFB033F3BD14C2BA68E797DFA4950F9307EC8E2C (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Rigidbody_get_velocity_Injected_m79C6BB8C054D0B5F03F3F13325910BC068E5B796(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = V_0;
return L_0;
}
}
// System.Void UnityEngine.Rigidbody::set_velocity(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_velocity_m8DC0988916EB38DFD7D4584830B41D79140BF18D (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
{
Rigidbody_set_velocity_Injected_mBFBC7681B33942F69A5CD908941D399777F66ADD(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___value0), /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Vector3 UnityEngine.Rigidbody::get_angularVelocity()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Rigidbody_get_angularVelocity_m6737340DF546452900D199246279231D80A21DCF (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Rigidbody_get_angularVelocity_Injected_mD00F8790DFF2A31A033487AC67C4C018F28D0D13(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = V_0;
return L_0;
}
}
// System.Void UnityEngine.Rigidbody::set_angularVelocity(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_angularVelocity_m3A40B7F195E9E217AE29A0964D7E7540E2E23080 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
{
Rigidbody_set_angularVelocity_Injected_m5ED47D0F131F6B3788B8B736DA7854FD63C13D56(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Single UnityEngine.Rigidbody::get_drag()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float Rigidbody_get_drag_m0C617963D9BBBC4018D3A8B2DB5D6190615F4A64 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
typedef float (*Rigidbody_get_drag_m0C617963D9BBBC4018D3A8B2DB5D6190615F4A64_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *);
static Rigidbody_get_drag_m0C617963D9BBBC4018D3A8B2DB5D6190615F4A64_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_get_drag_m0C617963D9BBBC4018D3A8B2DB5D6190615F4A64_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::get_drag()");
float icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.Rigidbody::set_drag(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_drag_m60E39BE31529DE5163116785A69FACC77C52DA98 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, float ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_drag_m60E39BE31529DE5163116785A69FACC77C52DA98_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, float);
static Rigidbody_set_drag_m60E39BE31529DE5163116785A69FACC77C52DA98_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_drag_m60E39BE31529DE5163116785A69FACC77C52DA98_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_drag(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Single UnityEngine.Rigidbody::get_angularDrag()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float Rigidbody_get_angularDrag_m0E53FD8F8A09DFA941C52C868288DBBC030C5082 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
typedef float (*Rigidbody_get_angularDrag_m0E53FD8F8A09DFA941C52C868288DBBC030C5082_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *);
static Rigidbody_get_angularDrag_m0E53FD8F8A09DFA941C52C868288DBBC030C5082_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_get_angularDrag_m0E53FD8F8A09DFA941C52C868288DBBC030C5082_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::get_angularDrag()");
float icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.Rigidbody::set_angularDrag(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_angularDrag_m8BF3771789B32FB09FDD8066BAFA0A0B661372A4 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, float ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_angularDrag_m8BF3771789B32FB09FDD8066BAFA0A0B661372A4_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, float);
static Rigidbody_set_angularDrag_m8BF3771789B32FB09FDD8066BAFA0A0B661372A4_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_angularDrag_m8BF3771789B32FB09FDD8066BAFA0A0B661372A4_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_angularDrag(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Single UnityEngine.Rigidbody::get_mass()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float Rigidbody_get_mass_mB7B19406DAC6336A8244E98BE271BDA8B5C26223 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
typedef float (*Rigidbody_get_mass_mB7B19406DAC6336A8244E98BE271BDA8B5C26223_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *);
static Rigidbody_get_mass_mB7B19406DAC6336A8244E98BE271BDA8B5C26223_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_get_mass_mB7B19406DAC6336A8244E98BE271BDA8B5C26223_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::get_mass()");
float icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Boolean UnityEngine.Rigidbody::get_useGravity()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Rigidbody_get_useGravity_mDA0FB6F456377840E6E46C42B9210F93264E2B28 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
typedef bool (*Rigidbody_get_useGravity_mDA0FB6F456377840E6E46C42B9210F93264E2B28_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *);
static Rigidbody_get_useGravity_mDA0FB6F456377840E6E46C42B9210F93264E2B28_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_get_useGravity_mDA0FB6F456377840E6E46C42B9210F93264E2B28_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::get_useGravity()");
bool icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.Rigidbody::set_useGravity(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_useGravity_m1057292FB3199E87664F40B8BCBA7A7E64D1A096 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, bool ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_useGravity_m1057292FB3199E87664F40B8BCBA7A7E64D1A096_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, bool);
static Rigidbody_set_useGravity_m1057292FB3199E87664F40B8BCBA7A7E64D1A096_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_useGravity_m1057292FB3199E87664F40B8BCBA7A7E64D1A096_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_useGravity(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Boolean UnityEngine.Rigidbody::get_isKinematic()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Rigidbody_get_isKinematic_m597B48C45021313B6C6C4B126E405EF566C5C80C (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
typedef bool (*Rigidbody_get_isKinematic_m597B48C45021313B6C6C4B126E405EF566C5C80C_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *);
static Rigidbody_get_isKinematic_m597B48C45021313B6C6C4B126E405EF566C5C80C_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_get_isKinematic_m597B48C45021313B6C6C4B126E405EF566C5C80C_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::get_isKinematic()");
bool icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.Rigidbody::set_isKinematic(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_isKinematic_mCF74D680205544826F2DE2CAB929C9F25409A311 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, bool ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_isKinematic_mCF74D680205544826F2DE2CAB929C9F25409A311_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, bool);
static Rigidbody_set_isKinematic_mCF74D680205544826F2DE2CAB929C9F25409A311_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_isKinematic_mCF74D680205544826F2DE2CAB929C9F25409A311_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_isKinematic(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Rigidbody::set_freezeRotation(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_freezeRotation_mE08A39E98D46F82D6DD86CC389D86D242C694D52 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, bool ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_freezeRotation_mE08A39E98D46F82D6DD86CC389D86D242C694D52_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, bool);
static Rigidbody_set_freezeRotation_mE08A39E98D46F82D6DD86CC389D86D242C694D52_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_freezeRotation_mE08A39E98D46F82D6DD86CC389D86D242C694D52_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_freezeRotation(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Rigidbody::set_constraints(UnityEngine.RigidbodyConstraints)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_constraints_mA76F562D16D3BE8889E095D0309C8FE38DA914F1 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, int32_t ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_constraints_mA76F562D16D3BE8889E095D0309C8FE38DA914F1_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, int32_t);
static Rigidbody_set_constraints_mA76F562D16D3BE8889E095D0309C8FE38DA914F1_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_constraints_mA76F562D16D3BE8889E095D0309C8FE38DA914F1_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_constraints(UnityEngine.RigidbodyConstraints)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Rigidbody::set_centerOfMass(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_centerOfMass_m3B13BE412D99CE5133606643F14501CF5C63CCEC (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
{
Rigidbody_set_centerOfMass_Injected_m60EC1BE2558EC9A9BD40ED144A1C848E6A4BCD9D(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::set_detectCollisions(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_detectCollisions_mB94256836724071B1EFE622A5E9BA435B6572E9A (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, bool ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_detectCollisions_mB94256836724071B1EFE622A5E9BA435B6572E9A_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, bool);
static Rigidbody_set_detectCollisions_mB94256836724071B1EFE622A5E9BA435B6572E9A_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_detectCollisions_mB94256836724071B1EFE622A5E9BA435B6572E9A_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_detectCollisions(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Vector3 UnityEngine.Rigidbody::get_position()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Rigidbody_get_position_m5F429382F610E324F39F33E8498A29D0828AD8E8 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Rigidbody_get_position_Injected_m16D551CF5A925BD26F4E77116483B2B36115A079(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = V_0;
return L_0;
}
}
// UnityEngine.Quaternion UnityEngine.Rigidbody::get_rotation()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 Rigidbody_get_rotation_mEB90F9D223B0BA32A1962971E3A93DEE1670D18A (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 V_0;
memset((&V_0), 0, sizeof(V_0));
{
Rigidbody_get_rotation_Injected_mA9DA175CC81C9D6D4D7098C34CF5378C4C2955D8(__this, (Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 *)(&V_0), /*hidden argument*/NULL);
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 L_0 = V_0;
return L_0;
}
}
// System.Void UnityEngine.Rigidbody::set_rotation(UnityEngine.Quaternion)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_rotation_m3024C151FEC9BB75735DE9B4BA64F16AA779C5D6 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___value0, const RuntimeMethod* method)
{
{
Rigidbody_set_rotation_Injected_mBB08A477E5E134A4E6FFF381BFDE9E2959844EE9(__this, (Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 *)(&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::set_maxAngularVelocity(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_maxAngularVelocity_m55AB6C34E2C33E6EABB07EFCB7AE443F5D3BD060 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, float ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_maxAngularVelocity_m55AB6C34E2C33E6EABB07EFCB7AE443F5D3BD060_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, float);
static Rigidbody_set_maxAngularVelocity_m55AB6C34E2C33E6EABB07EFCB7AE443F5D3BD060_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_maxAngularVelocity_m55AB6C34E2C33E6EABB07EFCB7AE443F5D3BD060_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_maxAngularVelocity(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Rigidbody::MovePosition(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_MovePosition_mB3CBBF21FD0ABB88BC6C004B993DED25673001C7 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position0, const RuntimeMethod* method)
{
{
Rigidbody_MovePosition_Injected_m06454253A0DF550B2EAD47F545734E8735BA0732(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___position0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::MoveRotation(UnityEngine.Quaternion)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_MoveRotation_m08A1449DC0D514A70065CD80D067597765BDA5B2 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___rot0, const RuntimeMethod* method)
{
{
Rigidbody_MoveRotation_Injected_mB730FBD0786AE2DEC454E76326E08ED79CEEF440(__this, (Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 *)(&___rot0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::Sleep()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_Sleep_m60350AEF3E52D57FBE448CADBC06BA98DAEA2115 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
typedef void (*Rigidbody_Sleep_m60350AEF3E52D57FBE448CADBC06BA98DAEA2115_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *);
static Rigidbody_Sleep_m60350AEF3E52D57FBE448CADBC06BA98DAEA2115_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_Sleep_m60350AEF3E52D57FBE448CADBC06BA98DAEA2115_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::Sleep()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.Rigidbody::AddForce(UnityEngine.Vector3,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddForce_m78B9D94F505E19F3C63461362AD6DE7EA0836700 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___force0, int32_t ___mode1, const RuntimeMethod* method)
{
{
int32_t L_0 = ___mode1;
Rigidbody_AddForce_Injected_m233C3E22C3FE9D2BCBBC510132B82CE26057370C(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___force0), L_0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::AddForce(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddForce_mDFB0D57C25682B826999B0074F5C0FD399C6401D (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___force0, const RuntimeMethod* method)
{
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___force0;
Rigidbody_AddForce_m78B9D94F505E19F3C63461362AD6DE7EA0836700(__this, L_0, 0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::AddTorque(UnityEngine.Vector3,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddTorque_mEDE3483056FB07222A4D096F22D45C7D8A6E2552 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___torque0, int32_t ___mode1, const RuntimeMethod* method)
{
{
int32_t L_0 = ___mode1;
Rigidbody_AddTorque_Injected_mFFD31FDF8F82D3D740EA83348BBC0D0D5EB0DB3A(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___torque0), L_0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::AddTorque(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddTorque_mAEB5758FA773B1A0ECDD328934BB3A7202D21EB3 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___torque0, const RuntimeMethod* method)
{
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___torque0;
Rigidbody_AddTorque_mEDE3483056FB07222A4D096F22D45C7D8A6E2552(__this, L_0, 0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::AddForceAtPosition(UnityEngine.Vector3,UnityEngine.Vector3,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddForceAtPosition_mEE49C058A6D57C1D5A78207494BFED5906D80D0F (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___force0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position1, int32_t ___mode2, const RuntimeMethod* method)
{
{
int32_t L_0 = ___mode2;
Rigidbody_AddForceAtPosition_Injected_m60ED364228EF475F97B0FF1D0F4EFCAB97382DDB(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___force0), (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___position1), L_0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::AddForceAtPosition(UnityEngine.Vector3,UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddForceAtPosition_m5190249D95CE1882B37481C5BFD2ABF201902BA5 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___force0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position1, const RuntimeMethod* method)
{
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___force0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_1 = ___position1;
Rigidbody_AddForceAtPosition_mEE49C058A6D57C1D5A78207494BFED5906D80D0F(__this, L_0, L_1, 0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::AddExplosionForce(System.Single,UnityEngine.Vector3,System.Single,System.Single,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddExplosionForce_mA81BFBF84914CEA89D18047ADE14B47D171280DD (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, float ___explosionForce0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___explosionPosition1, float ___explosionRadius2, float ___upwardsModifier3, int32_t ___mode4, const RuntimeMethod* method)
{
{
float L_0 = ___explosionForce0;
float L_1 = ___explosionRadius2;
float L_2 = ___upwardsModifier3;
int32_t L_3 = ___mode4;
Rigidbody_AddExplosionForce_Injected_m8CCDC7FDD8F5F1BC231094105B3076815A16E22D(__this, L_0, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___explosionPosition1), L_1, L_2, L_3, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody__ctor_m0E43BA3B0E70E71B2CA62B165EE5B7CFAEFACDE9 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, const RuntimeMethod* method)
{
{
Component__ctor_m0B00FA207EB3E560B78938D8AD877DB2BC1E3722(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody::get_velocity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_get_velocity_Injected_m79C6BB8C054D0B5F03F3F13325910BC068E5B796 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_get_velocity_Injected_m79C6BB8C054D0B5F03F3F13325910BC068E5B796_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static Rigidbody_get_velocity_Injected_m79C6BB8C054D0B5F03F3F13325910BC068E5B796_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_get_velocity_Injected_m79C6BB8C054D0B5F03F3F13325910BC068E5B796_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::get_velocity_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___ret0);
}
// System.Void UnityEngine.Rigidbody::set_velocity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_velocity_Injected_mBFBC7681B33942F69A5CD908941D399777F66ADD (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_velocity_Injected_mBFBC7681B33942F69A5CD908941D399777F66ADD_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static Rigidbody_set_velocity_Injected_mBFBC7681B33942F69A5CD908941D399777F66ADD_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_velocity_Injected_mBFBC7681B33942F69A5CD908941D399777F66ADD_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_velocity_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Rigidbody::get_angularVelocity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_get_angularVelocity_Injected_mD00F8790DFF2A31A033487AC67C4C018F28D0D13 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_get_angularVelocity_Injected_mD00F8790DFF2A31A033487AC67C4C018F28D0D13_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static Rigidbody_get_angularVelocity_Injected_mD00F8790DFF2A31A033487AC67C4C018F28D0D13_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_get_angularVelocity_Injected_mD00F8790DFF2A31A033487AC67C4C018F28D0D13_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::get_angularVelocity_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___ret0);
}
// System.Void UnityEngine.Rigidbody::set_angularVelocity_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_angularVelocity_Injected_m5ED47D0F131F6B3788B8B736DA7854FD63C13D56 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_angularVelocity_Injected_m5ED47D0F131F6B3788B8B736DA7854FD63C13D56_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static Rigidbody_set_angularVelocity_Injected_m5ED47D0F131F6B3788B8B736DA7854FD63C13D56_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_angularVelocity_Injected_m5ED47D0F131F6B3788B8B736DA7854FD63C13D56_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_angularVelocity_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Rigidbody::set_centerOfMass_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_centerOfMass_Injected_m60EC1BE2558EC9A9BD40ED144A1C848E6A4BCD9D (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_centerOfMass_Injected_m60EC1BE2558EC9A9BD40ED144A1C848E6A4BCD9D_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static Rigidbody_set_centerOfMass_Injected_m60EC1BE2558EC9A9BD40ED144A1C848E6A4BCD9D_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_centerOfMass_Injected_m60EC1BE2558EC9A9BD40ED144A1C848E6A4BCD9D_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_centerOfMass_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Rigidbody::get_position_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_get_position_Injected_m16D551CF5A925BD26F4E77116483B2B36115A079 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_get_position_Injected_m16D551CF5A925BD26F4E77116483B2B36115A079_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static Rigidbody_get_position_Injected_m16D551CF5A925BD26F4E77116483B2B36115A079_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_get_position_Injected_m16D551CF5A925BD26F4E77116483B2B36115A079_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::get_position_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___ret0);
}
// System.Void UnityEngine.Rigidbody::get_rotation_Injected(UnityEngine.Quaternion&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_get_rotation_Injected_mA9DA175CC81C9D6D4D7098C34CF5378C4C2955D8 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * ___ret0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_get_rotation_Injected_mA9DA175CC81C9D6D4D7098C34CF5378C4C2955D8_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 *);
static Rigidbody_get_rotation_Injected_mA9DA175CC81C9D6D4D7098C34CF5378C4C2955D8_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_get_rotation_Injected_mA9DA175CC81C9D6D4D7098C34CF5378C4C2955D8_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::get_rotation_Injected(UnityEngine.Quaternion&)");
_il2cpp_icall_func(__this, ___ret0);
}
// System.Void UnityEngine.Rigidbody::set_rotation_Injected(UnityEngine.Quaternion&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_set_rotation_Injected_mBB08A477E5E134A4E6FFF381BFDE9E2959844EE9 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * ___value0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_set_rotation_Injected_mBB08A477E5E134A4E6FFF381BFDE9E2959844EE9_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 *);
static Rigidbody_set_rotation_Injected_mBB08A477E5E134A4E6FFF381BFDE9E2959844EE9_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_set_rotation_Injected_mBB08A477E5E134A4E6FFF381BFDE9E2959844EE9_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::set_rotation_Injected(UnityEngine.Quaternion&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Rigidbody::MovePosition_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_MovePosition_Injected_m06454253A0DF550B2EAD47F545734E8735BA0732 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___position0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_MovePosition_Injected_m06454253A0DF550B2EAD47F545734E8735BA0732_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static Rigidbody_MovePosition_Injected_m06454253A0DF550B2EAD47F545734E8735BA0732_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_MovePosition_Injected_m06454253A0DF550B2EAD47F545734E8735BA0732_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::MovePosition_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___position0);
}
// System.Void UnityEngine.Rigidbody::MoveRotation_Injected(UnityEngine.Quaternion&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_MoveRotation_Injected_mB730FBD0786AE2DEC454E76326E08ED79CEEF440 (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * ___rot0, const RuntimeMethod* method)
{
typedef void (*Rigidbody_MoveRotation_Injected_mB730FBD0786AE2DEC454E76326E08ED79CEEF440_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 *);
static Rigidbody_MoveRotation_Injected_mB730FBD0786AE2DEC454E76326E08ED79CEEF440_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_MoveRotation_Injected_mB730FBD0786AE2DEC454E76326E08ED79CEEF440_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::MoveRotation_Injected(UnityEngine.Quaternion&)");
_il2cpp_icall_func(__this, ___rot0);
}
// System.Void UnityEngine.Rigidbody::AddForce_Injected(UnityEngine.Vector3&,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddForce_Injected_m233C3E22C3FE9D2BCBBC510132B82CE26057370C (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___force0, int32_t ___mode1, const RuntimeMethod* method)
{
typedef void (*Rigidbody_AddForce_Injected_m233C3E22C3FE9D2BCBBC510132B82CE26057370C_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, int32_t);
static Rigidbody_AddForce_Injected_m233C3E22C3FE9D2BCBBC510132B82CE26057370C_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_AddForce_Injected_m233C3E22C3FE9D2BCBBC510132B82CE26057370C_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::AddForce_Injected(UnityEngine.Vector3&,UnityEngine.ForceMode)");
_il2cpp_icall_func(__this, ___force0, ___mode1);
}
// System.Void UnityEngine.Rigidbody::AddTorque_Injected(UnityEngine.Vector3&,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddTorque_Injected_mFFD31FDF8F82D3D740EA83348BBC0D0D5EB0DB3A (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___torque0, int32_t ___mode1, const RuntimeMethod* method)
{
typedef void (*Rigidbody_AddTorque_Injected_mFFD31FDF8F82D3D740EA83348BBC0D0D5EB0DB3A_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, int32_t);
static Rigidbody_AddTorque_Injected_mFFD31FDF8F82D3D740EA83348BBC0D0D5EB0DB3A_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_AddTorque_Injected_mFFD31FDF8F82D3D740EA83348BBC0D0D5EB0DB3A_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::AddTorque_Injected(UnityEngine.Vector3&,UnityEngine.ForceMode)");
_il2cpp_icall_func(__this, ___torque0, ___mode1);
}
// System.Void UnityEngine.Rigidbody::AddForceAtPosition_Injected(UnityEngine.Vector3&,UnityEngine.Vector3&,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddForceAtPosition_Injected_m60ED364228EF475F97B0FF1D0F4EFCAB97382DDB (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___force0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___position1, int32_t ___mode2, const RuntimeMethod* method)
{
typedef void (*Rigidbody_AddForceAtPosition_Injected_m60ED364228EF475F97B0FF1D0F4EFCAB97382DDB_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, int32_t);
static Rigidbody_AddForceAtPosition_Injected_m60ED364228EF475F97B0FF1D0F4EFCAB97382DDB_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_AddForceAtPosition_Injected_m60ED364228EF475F97B0FF1D0F4EFCAB97382DDB_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::AddForceAtPosition_Injected(UnityEngine.Vector3&,UnityEngine.Vector3&,UnityEngine.ForceMode)");
_il2cpp_icall_func(__this, ___force0, ___position1, ___mode2);
}
// System.Void UnityEngine.Rigidbody::AddExplosionForce_Injected(System.Single,UnityEngine.Vector3&,System.Single,System.Single,UnityEngine.ForceMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Rigidbody_AddExplosionForce_Injected_m8CCDC7FDD8F5F1BC231094105B3076815A16E22D (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A * __this, float ___explosionForce0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___explosionPosition1, float ___explosionRadius2, float ___upwardsModifier3, int32_t ___mode4, const RuntimeMethod* method)
{
typedef void (*Rigidbody_AddExplosionForce_Injected_m8CCDC7FDD8F5F1BC231094105B3076815A16E22D_ftn) (Rigidbody_t101F2E2F9F16E765A77429B2DE4527D2047A887A *, float, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *, float, float, int32_t);
static Rigidbody_AddExplosionForce_Injected_m8CCDC7FDD8F5F1BC231094105B3076815A16E22D_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody_AddExplosionForce_Injected_m8CCDC7FDD8F5F1BC231094105B3076815A16E22D_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody::AddExplosionForce_Injected(System.Single,UnityEngine.Vector3&,System.Single,System.Single,UnityEngine.ForceMode)");
_il2cpp_icall_func(__this, ___explosionForce0, ___explosionPosition1, ___explosionRadius2, ___upwardsModifier3, ___mode4);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector3 UnityEngine.SphereCollider::get_center()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E SphereCollider_get_center_mBFAE4FFFC76B8FD8F1B2B2F12C52A30470443D3A (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A * __this, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
SphereCollider_get_center_Injected_mF082CC62A7E8DE3DD5B86518C210D85139DD93CB(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&V_0), /*hidden argument*/NULL);
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = V_0;
return L_0;
}
}
// System.Void UnityEngine.SphereCollider::set_center(UnityEngine.Vector3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SphereCollider_set_center_mD5E898A2FED304A82BC67ABB11B60BB0F612CED7 (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value0, const RuntimeMethod* method)
{
{
SphereCollider_set_center_Injected_mB213D6CB194E150BBEF8EC2AA31EA391C2F4A641(__this, (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *)(&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Single UnityEngine.SphereCollider::get_radius()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float SphereCollider_get_radius_m403989140BDAD513299276953B481167CF08D02F (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A * __this, const RuntimeMethod* method)
{
typedef float (*SphereCollider_get_radius_m403989140BDAD513299276953B481167CF08D02F_ftn) (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A *);
static SphereCollider_get_radius_m403989140BDAD513299276953B481167CF08D02F_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (SphereCollider_get_radius_m403989140BDAD513299276953B481167CF08D02F_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.SphereCollider::get_radius()");
float icallRetVal = _il2cpp_icall_func(__this);
return icallRetVal;
}
// System.Void UnityEngine.SphereCollider::set_radius(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SphereCollider_set_radius_m55A0D144B32871AECC2A83FBCF423FBE1E5A63A0 (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A * __this, float ___value0, const RuntimeMethod* method)
{
typedef void (*SphereCollider_set_radius_m55A0D144B32871AECC2A83FBCF423FBE1E5A63A0_ftn) (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A *, float);
static SphereCollider_set_radius_m55A0D144B32871AECC2A83FBCF423FBE1E5A63A0_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (SphereCollider_set_radius_m55A0D144B32871AECC2A83FBCF423FBE1E5A63A0_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.SphereCollider::set_radius(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.SphereCollider::get_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SphereCollider_get_center_Injected_mF082CC62A7E8DE3DD5B86518C210D85139DD93CB (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___ret0, const RuntimeMethod* method)
{
typedef void (*SphereCollider_get_center_Injected_mF082CC62A7E8DE3DD5B86518C210D85139DD93CB_ftn) (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static SphereCollider_get_center_Injected_mF082CC62A7E8DE3DD5B86518C210D85139DD93CB_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (SphereCollider_get_center_Injected_mF082CC62A7E8DE3DD5B86518C210D85139DD93CB_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.SphereCollider::get_center_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___ret0);
}
// System.Void UnityEngine.SphereCollider::set_center_Injected(UnityEngine.Vector3&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SphereCollider_set_center_Injected_mB213D6CB194E150BBEF8EC2AA31EA391C2F4A641 (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * ___value0, const RuntimeMethod* method)
{
typedef void (*SphereCollider_set_center_Injected_mB213D6CB194E150BBEF8EC2AA31EA391C2F4A641_ftn) (SphereCollider_t51A338502EEE6FA563248E3C0BF38D333077DC3A *, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E *);
static SphereCollider_set_center_Injected_mB213D6CB194E150BBEF8EC2AA31EA391C2F4A641_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (SphereCollider_set_center_Injected_mB213D6CB194E150BBEF8EC2AA31EA391C2F4A641_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.SphereCollider::set_center_Injected(UnityEngine.Vector3&)");
_il2cpp_icall_func(__this, ___value0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.SpringJoint::set_spring(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SpringJoint_set_spring_mD13E36119ECED2503EBD1C04AEBBD75B91757429 (SpringJoint_t6F2ACC63AD7C975D92271BC2DE2B564087DC27BF * __this, float ___value0, const RuntimeMethod* method)
{
typedef void (*SpringJoint_set_spring_mD13E36119ECED2503EBD1C04AEBBD75B91757429_ftn) (SpringJoint_t6F2ACC63AD7C975D92271BC2DE2B564087DC27BF *, float);
static SpringJoint_set_spring_mD13E36119ECED2503EBD1C04AEBBD75B91757429_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (SpringJoint_set_spring_mD13E36119ECED2503EBD1C04AEBBD75B91757429_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.SpringJoint::set_spring(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.SpringJoint::set_damper(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SpringJoint_set_damper_m48539DD75A85D3CF6E57A058D71FF17C2F96DD7B (SpringJoint_t6F2ACC63AD7C975D92271BC2DE2B564087DC27BF * __this, float ___value0, const RuntimeMethod* method)
{
typedef void (*SpringJoint_set_damper_m48539DD75A85D3CF6E57A058D71FF17C2F96DD7B_ftn) (SpringJoint_t6F2ACC63AD7C975D92271BC2DE2B564087DC27BF *, float);
static SpringJoint_set_damper_m48539DD75A85D3CF6E57A058D71FF17C2F96DD7B_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (SpringJoint_set_damper_m48539DD75A85D3CF6E57A058D71FF17C2F96DD7B_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.SpringJoint::set_damper(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.SpringJoint::set_maxDistance(System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SpringJoint_set_maxDistance_m1490994DABABA9CA28431AB8CF53DCF0C5C7DD00 (SpringJoint_t6F2ACC63AD7C975D92271BC2DE2B564087DC27BF * __this, float ___value0, const RuntimeMethod* method)
{
typedef void (*SpringJoint_set_maxDistance_m1490994DABABA9CA28431AB8CF53DCF0C5C7DD00_ftn) (SpringJoint_t6F2ACC63AD7C975D92271BC2DE2B564087DC27BF *, float);
static SpringJoint_set_maxDistance_m1490994DABABA9CA28431AB8CF53DCF0C5C7DD00_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (SpringJoint_set_maxDistance_m1490994DABABA9CA28431AB8CF53DCF0C5C7DD00_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.SpringJoint::set_maxDistance(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Vector3_op_Subtraction_m2725C96965D5C0B1F9715797E51762B13A5FED58_inline (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___a0, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___b1, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___a0;
float L_1 = L_0.get_x_2();
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_2 = ___b1;
float L_3 = L_2.get_x_2();
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_4 = ___a0;
float L_5 = L_4.get_y_3();
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_6 = ___b1;
float L_7 = L_6.get_y_3();
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_8 = ___a0;
float L_9 = L_8.get_z_4();
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_10 = ___b1;
float L_11 = L_10.get_z_4();
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_12;
memset((&L_12), 0, sizeof(L_12));
Vector3__ctor_m57495F692C6CE1CEF278CAD9A98221165D37E636_inline((&L_12), ((float)il2cpp_codegen_subtract((float)L_1, (float)L_3)), ((float)il2cpp_codegen_subtract((float)L_5, (float)L_7)), ((float)il2cpp_codegen_subtract((float)L_9, (float)L_11)), /*hidden argument*/NULL);
V_0 = L_12;
goto IL_0030;
}
IL_0030:
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_13 = V_0;
return L_13;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E Vector3_op_Division_mE5ACBFB168FED529587457A83BA98B7DB32E2A05_inline (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___a0, float ___d1, const RuntimeMethod* method)
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E V_0;
memset((&V_0), 0, sizeof(V_0));
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_0 = ___a0;
float L_1 = L_0.get_x_2();
float L_2 = ___d1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_3 = ___a0;
float L_4 = L_3.get_y_3();
float L_5 = ___d1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_6 = ___a0;
float L_7 = L_6.get_z_4();
float L_8 = ___d1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_9;
memset((&L_9), 0, sizeof(L_9));
Vector3__ctor_m57495F692C6CE1CEF278CAD9A98221165D37E636_inline((&L_9), ((float)((float)L_1/(float)L_2)), ((float)((float)L_4/(float)L_5)), ((float)((float)L_7/(float)L_8)), /*hidden argument*/NULL);
V_0 = L_9;
goto IL_0021;
}
IL_0021:
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E L_10 = V_0;
return L_10;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void Vector3__ctor_m57495F692C6CE1CEF278CAD9A98221165D37E636_inline (Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * __this, float ___x0, float ___y1, float ___z2, const RuntimeMethod* method)
{
{
float L_0 = ___x0;
__this->set_x_2(L_0);
float L_1 = ___y1;
__this->set_y_3(L_1);
float L_2 = ___z2;
__this->set_z_4(L_2);
return;
}
}
| [
"ss3448@scarletmail.rutgers.edu"
] | ss3448@scarletmail.rutgers.edu |
82b1dd6b4ecd8240b9895a2164fcfd2006cb91eb | fd279e622dd6d2788e5613349fc5a060a2edd031 | /HomeTask_03/Printer/fileprinter.h | 74064116c4952326d7ed0cfb7b1cff6b32e0b568 | [] | no_license | VeselovAlex/SecondTerm | 7a7e58d292dcfd17a00a5b99ec19169f24a9235a | 124da3c0ca80485cf5a20cad215ef40ae651b80c | refs/heads/master | 2021-03-12T22:12:57.867207 | 2013-05-27T13:35:17 | 2013-05-27T13:35:17 | 8,334,959 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 533 | h | #ifndef FILEPRINTER_H
#define FILEPRINTER_H
#include "printer.h"
#include <iostream>
#include <fstream>
/**
* @brief The File Printer class
*/
class FilePrinter : public Printer
{
public:
/**
* @brief FilePrinter constructor
* @param file Path to output file
*/
FilePrinter(const char *file) : filename(file){}
/**
* @brief print prints string to file
* @param toPrint String to print
*/
void print(std::string toPrint);
private:
const char *filename;
};
#endif // FILEPRINTER_H
| [
"veselov143@gmail.com"
] | veselov143@gmail.com |
5eb96b7ff682ec657d0de64cd0beb3a139a194a8 | 315b4721a030871f23aa68b29e81dead78d93a82 | /tioj1199.cpp | a15a7e292be0c1b51c3b3e5c6771ddd965fd3f7a | [] | no_license | ArutoriaWhite/Competitive-programming | ce71166ac51929ed6d37761256dfdfee7ebd207e | e19642bd76f1fa12b1162930c4a7f3b199cd2573 | refs/heads/master | 2023-06-16T21:58:01.308407 | 2021-07-19T12:07:12 | 2021-07-19T12:07:12 | 216,078,983 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 736 | cpp | #include <bits/stdc++.h>
#define de(x) cout << #x << "=" << x << ", "
#define dd cout << '\n';
#define rep(i,j,k) for (int i=j; i<=k; i++)
#define XinAi ios::sync_with_stdio(0), cin.tie(0);
#define F first
#define S second
#define int long long
using namespace std;
typedef pair<int,int> pii;
int qpow (int a, int b, int m)
{
int res;
for (res=1; b; b>>=1,a=(a*a%m))
if (b&1) res = (res*a)%m;
return res;
}
signed main()
{
XinAi
int a, b, c;
while (cin >> a >> b >> c, (a||b||c))
{
int res = 0;
rep(i, 0, c-1)
{
if (i==0 && b==0) continue;
if (qpow(i, b, c) == a) res++;
}
cout << res << '\n';
}
}
| [
"aatroxvanz@gmail.com"
] | aatroxvanz@gmail.com |
114d6968ae9efd1c399f4a5d75494a3fa5c62614 | 9c85df296a2c959374bb0d9bdc875d82b2ccf8a8 | /SM/src/GNN.cc | 078ad8ddd4a04ab0434831c087fa5ec6f57eb9dd | [
"BSD-3-Clause"
] | permissive | zhulongchao/MTF | 7de51a8a65d60ec5138952b48a9334e266ff6d06 | 196c66be21a88f079d00ddb1da227b3f91d1411a | refs/heads/master | 2021-01-19T19:10:06.951611 | 2017-04-16T06:18:10 | 2017-04-16T06:18:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,099 | cc | #include "mtf/SM/GNN.h"
#include "mtf/Utilities//miscUtils.h"
#include <fstream>
_MTF_BEGIN_NAMESPACE
namespace gnn{
GNNParams::GNNParams(int _degree, int _max_steps,
int _cmpt_dist_thresh, bool _random_start,
bool _verbose) :
degree(_degree),
max_steps(_max_steps),
cmpt_dist_thresh(_cmpt_dist_thresh),
random_start(_random_start),
verbose(_verbose){}
GNNParams::GNNParams(const GNNParams *params) :
degree(GNN_DEGREE),
max_steps(GNN_MAX_STEPS),
cmpt_dist_thresh(GNN_CMPT_DIST_THRESH),
random_start(GNN_RANDOM_START),
verbose(GNN_VERBOSE){
if(params){
degree = params->degree;
max_steps = params->max_steps;
cmpt_dist_thresh = params->cmpt_dist_thresh;
random_start = params->random_start;
verbose = params->verbose;
}
}
template <class AM>
GNN<AM>::GNN(const AM *_dist_func, int _n_samples, int _n_dims,
bool _is_symmetrical, const ParamType *gnn_params) :
dist_func(_dist_func),
n_samples(_n_samples),
n_dims(_n_dims),
is_symmetrical(_is_symmetrical),
params(gnn_params) {
if(params.degree == 0 || params.degree > n_samples){
params.degree = n_samples;
} else if(params.degree < 0){
params.degree = -n_samples / params.degree;
}
printf("Using Graph based NN with:\n");
printf("degree: %d\n", params.degree);
printf("max_steps: %d\n", params.max_steps);
printf("cmpt_dist_thresh: %d\n", params.cmpt_dist_thresh);
printf("random_start: %d\n", params.random_start);
printf("verbose: %d\n", params.verbose);
dist_computed = false;
start_node_idx = getRandNum(0, n_samples - 1);
}
template <class AM>
void GNN<AM>::computeDistances(const double *dataset){
dataset_distances.resize(n_samples, n_samples);
if(params.verbose){
printf("Computing distances between samples...\n");
}
mtf_clock_get(dist_state_time);
for(int id1 = 0; id1 < n_samples; ++id1){
const double* sample1 = dataset + (id1*n_dims);
dataset_distances(id1, id1) = (*dist_func)(sample1, sample1, n_dims);
for(int id2 = id1 + 1; id2 < n_samples; ++id2){
const double* sample2 = dataset + (id2*n_dims);
dataset_distances(id1, id2) = (*dist_func)(sample1, sample2, n_dims);
dataset_distances(id2, id1) = is_symmetrical ? dataset_distances(id1, id2) :
(*dist_func)(sample2, sample1, n_dims);
}
if(params.verbose){
mtf_clock_get(end_time);
double elapsed_time;
mtf_clock_measure(dist_state_time, end_time, elapsed_time);
if((id1 + 1) % 100 == 0){
printf("Done %d/%d samples (%6.2f%%). Time elapsed: %f secs...\n",
id1 + 1, n_samples, double(id1 + 1) / double(n_samples) * 100,
elapsed_time);
}
}
}
dist_computed = true;
}
template <class AM>
void GNN<AM>::buildGraph(const double *dataset){
if(!dist_computed && n_samples <= params.cmpt_dist_thresh){
// distance is pre computed and stored only if the no. of samples is not large enough to
// cause a bad_alloc error on attempting to allocate memory for this
computeDistances(dataset);
}
nodes.resize(n_samples);
std::vector<IndxDist> dists(params.degree + 1);
if(params.verbose){
printf("Processing graph nodes...\n");
}
mtf_clock_get(build_state_time);
for(int id1 = 0; id1 < n_samples; ++id1){
nodes[id1].nns_inds.resize(params.degree);
nodes[id1].capacity = params.degree;
nodes[id1].size = 0;
int count = 0;
for(int id2 = 0; id2 < n_samples; ++id2){
double dist = dist_computed ? dataset_distances(id1, id2) :
(*dist_func)(dataset + (id1*n_dims), dataset + (id2*n_dims), n_dims);
if(count < params.degree + 1){
dists[count].idx = id2;
dists[count].dist = dist;
++count;
} else if(dist < dists[count - 1].dist || (dist == dists[count - 1].dist &&
id2 < dists[count - 1].idx)) {
dists[count - 1].idx = id2;
dists[count - 1].dist = dist;
} else {
continue;
}
int id3 = count - 1;
while(id3 >= 1 && (dists[id3].dist < dists[id3 - 1].dist || (dists[id3].dist == dists[id3 - 1].dist &&
dists[id3].idx < dists[id3 - 1].idx))){
swap<int>(&dists[id3].idx, &dists[id3 - 1].idx);
swap<double>(&dists[id3].dist, &dists[id3 - 1].dist);
--id3;
}
}
for(int j = 0; j < params.degree; j++){
int nns_ind = dists[j + 1].idx;
addNode(&nodes[id1], nns_ind);
}
if(params.verbose){
mtf_clock_get(end_time);
double elapsed_time;
mtf_clock_measure(build_state_time, end_time, elapsed_time);
if((id1 + 1) % 100 == 0){
printf("Done %d/%d nodes (%6.2f%%). Time elapsed: %f secs...\n",
id1 + 1, n_samples, double(id1 + 1) / double(n_samples) * 100,
elapsed_time);
}
}
}
}
template <class AM>
void GNN<AM>::searchGraph(const double *query, const double *dataset,
int *nn_ids, double *nn_dists, int K){
int gnns_cap = K;
int visited_cap = K * 4; //avg depth = 4
int visited = 0; // number of visited nodes
IndxDist *gnn_dists = static_cast<IndxDist*>(malloc(gnns_cap * sizeof(IndxDist))); // graph nn-dists
IndxDist *visited_nodes = static_cast<IndxDist*>(malloc(visited_cap * sizeof(IndxDist)));
if(params.random_start){
start_node_idx = getRandNum(0, n_samples - 1);
}
int r = start_node_idx;
int parent_dist = (*dist_func)(query, &dataset[r*n_dims], n_dims);
visited_nodes[0].idx = r;
visited_nodes[0].dist = parent_dist;
visited++;
bool nn_found = false;
for(int step_id = 0; step_id < params.max_steps; ++step_id){
if(nodes[r].size > gnns_cap) {
gnns_cap = nodes[r].size;
gnn_dists = static_cast<IndxDist*>(realloc(gnn_dists, gnns_cap * sizeof(IndxDist)));
}
int count = 0;
//printf("Nodes[%d].size: %d\n", r, Nodes[r].size);
for(int id1 = 0; id1 < nodes[r].size; id1++){
//printf("Nodes[%d].nns_inds[%d]: %d\n", r, id1, Nodes[r].nns_inds[id1]);
const double *point = dataset + nodes[r].nns_inds[id1] * n_dims;
double dist = (*dist_func)(query, point, n_dims);
if(count < K){
gnn_dists[count].idx = id1; // the ids stored in gnn_dists are w.r.t. the current parent node
// rather than the dataset itself
gnn_dists[count].dist = dist;
++count;
} else if(dist < gnn_dists[count - 1].dist || (dist == gnn_dists[count - 1].dist &&
id1 < gnn_dists[count - 1].idx)) {
gnn_dists[count - 1].idx = id1;
gnn_dists[count - 1].dist = dist;
} else {
continue;
}
int id2 = count - 1;
while(id2 >= 1 && (gnn_dists[id2].dist < gnn_dists[id2 - 1].dist || (gnn_dists[id2].dist == gnn_dists[id2 - 1].dist &&
gnn_dists[id2].idx < gnn_dists[id2 - 1].idx))){
swap<int>(&gnn_dists[id2].idx, &gnn_dists[id2 - 1].idx);
swap<double>(&gnn_dists[id2].dist, &gnn_dists[id2 - 1].dist);
id2--;
}
}
int m = min(K, nodes[r].size); // no. of connected nodes visited for the current parent node
if((visited + m) > visited_cap){
do {
visited_cap *= 2;
} while(visited_cap < (visited + m));
visited_nodes = static_cast<IndxDist*>(realloc(visited_nodes, visited_cap *sizeof(IndxDist)));
}
// add the visited nodes of the current parent node to the list of visited nodes
for(int i = 0; i < m; i++){
visited_nodes[visited + i].idx = nodes[r].nns_inds[gnn_dists[i].idx];
visited_nodes[visited + i].dist = gnn_dists[i].dist;
}
visited = visited + m;
if(parent_dist <= gnn_dists[0].dist){
nn_found = true;
break;
}
r = nodes[r].nns_inds[gnn_dists[0].idx]; // move to the nearest neighbor of the current parent node
parent_dist = (*dist_func)(query, &dataset[r*n_dims], n_dims);
}
if(params.verbose && !nn_found){
printf("GNN::Maximum steps reached\n");
}
qsort(visited_nodes, visited, sizeof(visited_nodes[0]), cmpQsort); //Ascending...
/**
next search will start at the nearest neighbor found in this search
to facilitate faster convergence if the next quey point is similar
to the current one - a valid assumption with tracking where nearby frames
exhibit high correlation
*/
start_node_idx = visited_nodes[0].idx;
for(int i = 0; i < K; i++){
nn_ids[i] = visited_nodes[i].idx;
nn_dists[i] = visited_nodes[i].dist;
}
}
template <class AM>
void GNN<AM>::saveGraph(const char* saved_graph_path){
ofstream out_file(saved_graph_path, ios::out | ios::binary);
if(out_file.good()){
printf("Saving GNN graph to: %s\n", saved_graph_path);
out_file.write((char*)(&n_samples), sizeof(int));
out_file.write((char*)(&n_dims), sizeof(int));
out_file.write((char*)(nodes.data()), n_samples*sizeof(Node));
for(int node_id = 0; node_id < n_samples; node_id++){
out_file.write((char*)(nodes[node_id].nns_inds.data()),
nodes[node_id].capacity*sizeof(int));
}
out_file.close();
} else{
printf("Failed to saved GNN graph to: %s\n", saved_graph_path);
}
}
template <class AM>
void GNN<AM>::loadGraph(const char* saved_graph_path){
ifstream in_file(saved_graph_path, ios::in | ios::binary);
if(in_file.good()){
printf("Loading GNN graph from: %s\n", saved_graph_path);
in_file.read((char*)(&n_samples), sizeof(int));
in_file.read((char*)(&n_dims), sizeof(int));
printf("n_samples: %d\n", n_samples);
printf("n_dims: %d\n", n_dims);
nodes.resize(n_samples);
in_file.read((char*)(nodes.data()), n_samples*sizeof(Node));
for(int node_id = 0; node_id < n_samples; node_id++){
nodes[node_id].nns_inds.resize(nodes[node_id].capacity);
in_file.read((char*)(nodes[node_id].nns_inds.data()), nodes[node_id].capacity*sizeof(int));
}
in_file.close();
} else{
printf("Failed to load GNN graph from: %s\n", saved_graph_path);
}
}
template <class AM>
void GNN<AM>::buildGraph(const double *X, int k){
nodes.resize(n_samples);
for(int i = 0; i < n_samples; i++){
nodes[i].nns_inds.resize(k);
// memset(Nodes[i].nns_inds, -1, k*sizeof(int));
nodes[i].capacity = k;
nodes[i].size = 0;
}
// struct indx_dist *dists = malloc(n_samples * sizeof(struct indx_dist));
// check_pointer(dists, "Couldn't malloc dists");
std::vector<IndxDist> dists(k + 1);
// int *nns_ind = malloc(k*sizeof(int));
// check_pointer(nns_ind, "Couldn't malloc nns_ind");
// int *query = malloc(n_dims*sizeof(int));
// check_pointer(query, "Couldn't malloc query");
for(int i = 0; i < n_samples; i++){
knnSearch2(X + (i*n_dims), dists.data(), X, n_samples, n_dims, k + 1); // index of 1st node is 0
for(int j = 0; j < k; j++){
int nns_ind = dists[j + 1].idx;
addNode(&nodes[i], nns_ind);
}
}
}
template <class AM>
int GNN<AM>::searchGraph(const double *query, const double *X, int NNs, int K){
IndxDist *gnn_dists, *knns, *visited_nodes;
int gnns_cap = K; //NNs*3;
gnn_dists = static_cast<IndxDist*>(malloc(gnns_cap * sizeof(IndxDist))); // graph nn-dists
int dist_cnt, depth;
//tnn_dists = realloc(tnn_dists, K * sizeof(struct indx_dist)); // shrinks the size to K
// Graph search time
int visited_cap = K * 4; //avg depth = 4
int visited = 0; // number of visited nodes
visited_nodes = static_cast<IndxDist*>(malloc(visited_cap * sizeof(IndxDist)));
double parent_dist, dd;
depth = 0;
dist_cnt = 0;
int r = start_node_idx;
parent_dist = (*dist_func)(query, &X[r*n_dims], n_dims);
// parent_dist = my_dist(query, x_row, n_dims);
visited_nodes[0].idx = r;
visited_nodes[0].dist = parent_dist;
visited++;
while(true){
// X1 = sample_X(Nodes, r, X); //contains the neighbors of node r
if(nodes[r].size > gnns_cap) //Nodes[r].size != gnns_size)
{
gnns_cap = nodes[r].size;
gnn_dists = static_cast<IndxDist*>(realloc(gnn_dists, gnns_cap * sizeof(IndxDist)));
}
// knn_search(query, gnn_dists, X1, Nodes[r].size, n_dims);
// knn_search1(query, gnn_dists, X, Nodes[r].size, n_dims, Nodes[r].nns_inds);
knnSearch11(query, gnn_dists, X, nodes[r].size, n_dims, K, nodes[r].nns_inds.data());
// free(X1);
int m = min(K, nodes[r].size);
if((visited + m) > visited_cap){
do {
visited_cap *= 2;
} while(visited_cap < (visited + m));
visited_nodes = static_cast<IndxDist*>(realloc(visited_nodes, visited_cap *sizeof(IndxDist)));
}
for(int i = 0; i < m; i++){
visited_nodes[visited + i].idx = nodes[r].nns_inds[gnn_dists[i].idx];
visited_nodes[visited + i].dist = gnn_dists[i].dist;
}
visited = visited + m;
if(parent_dist <= gnn_dists[0].dist)
break;
else
dd = gnn_dists[0].dist;
r = nodes[r].nns_inds[gnn_dists[0].idx];
depth++;
dist_cnt += nodes[r].size;
// parent_dist = my_dist(query, x_row, n_dims);
parent_dist = (*dist_func)(query, &X[r*n_dims], n_dims);
}
//gnns_size = K;
//gnn_dists = realloc(gnn_dists, gnns_size * sizeof(struct indx_dist));
//check_pointer(gnn_dists, "Couldn't realloc gnn_dists");
// Given visited_nodes and their dists, selects the first knns and puts into gnns_dists
pickKNNs(visited_nodes, visited, &gnn_dists, K, &gnns_cap);
start_node_idx = gnn_dists[0].idx;
return gnn_dists[0].idx;
}
template <class AM>
void GNN<AM>::pickKNNs(IndxDist *vis_nodes, int visited,
IndxDist **gnn_dists, int K, int *gnns_cap){
qsort(vis_nodes, visited, sizeof(vis_nodes[0]), cmpQsort); //Ascending...
if(K > *gnns_cap){
*gnns_cap = K;
*gnn_dists = static_cast<IndxDist*>(realloc(*gnn_dists, K*sizeof(IndxDist))); // not needed? not sure
}
int found = 0, ii = 0, jj = 0;
(*gnn_dists)[jj].idx = vis_nodes[ii].idx;
(*gnn_dists)[jj].dist = vis_nodes[ii].dist;
ii++; jj++;
while(jj < K){
// i++;
found = 0;
for(int j = 0; j < jj; j++)
if((*gnn_dists)[j].idx == vis_nodes[ii].idx){
found = 1; break;
}
if(found){
ii++; continue;
} else{
(*gnn_dists)[jj].idx = vis_nodes[ii].idx;
(*gnn_dists)[jj].dist = vis_nodes[ii].dist;
jj++; ii++;
}
}
}
template <class AM>
void GNN<AM>::knnSearch2(const double *Q, IndxDist *dists,
const double *X, int rows, int cols, int k){
// Faster version of knn_search
// Calculates the distance of query to all data points in X and returns the sorted dist array
/* for (i=0; i<rows; i++)
{
dists[i].dist = (*dist_func)(Q, X+i*cols, cols);
dists[i].idx = i;
}
mergesort(dists, 0, rows-1);
*/
int index, ii, count = 0;
//int capacity = k;
for(index = 0; index < rows; index++){
const double *point = X + index*cols;
for(ii = 0; ii < count; ++ii) {
if(dists[ii].idx == ii) continue; //return false;
}
//addPoint(point);
double dist = (*dist_func)(Q, point, cols);
if(count < k){
dists[count].idx = index;
dists[count].dist = dist;
++count;
} else if(dist < dists[count - 1].dist || (dist == dists[count - 1].dist &&
index < dists[count - 1].idx)) {
// else if (dist < dists[count-1]) {
dists[count - 1].idx = index;
dists[count - 1].dist = dist;
} else {
continue; // return false;
}
int i = count - 1;
while(i >= 1 && (dists[i].dist < dists[i - 1].dist || (dists[i].dist == dists[i - 1].dist &&
dists[i].idx < dists[i - 1].idx))){
swap<int>(&dists[i].idx, &dists[i - 1].idx);
swap<double>(&dists[i].dist, &dists[i - 1].dist);
i--;
}
//return false;
}
}
template <class AM>
void GNN<AM>::knnSearch11(const double *Q, IndxDist *dists, const double *X,
int rows, int cols, int k, int *X_inds){
// Faster version of knn_search1
// Calculates the distance of query to all data points in X and returns the sorted dist array
int count = 0;
for(int i = 0; i < rows; i++){
//for(int j = 0; j < count; ++j) {
// if(dists[j].idx == j) continue; //return false;
//}
//printf("X_inds[%d]: %d\n", i, X_inds[i]);
const double *point = X + X_inds[i] * cols;
double dist = (*dist_func)(Q, point, cols);
if(count < k){
dists[count].idx = i;
dists[count].dist = dist;
++count;
} else if(dist < dists[count - 1].dist || (dist == dists[count - 1].dist &&
i < dists[count - 1].idx)) {
// else if (dist < dists[count-1]) {
dists[count - 1].idx = i;
dists[count - 1].dist = dist;
} else {
continue; // return false;
}
int ii = count - 1;
while(ii >= 1 && (dists[ii].dist < dists[ii - 1].dist || (dists[ii].dist == dists[ii - 1].dist &&
dists[ii].idx < dists[ii - 1].idx))){
swap<int>(&dists[ii].idx, &dists[ii - 1].idx);
swap<double>(&dists[ii].dist, &dists[ii - 1].dist);
ii--;
}
}
}
template <class AM>
void GNN<AM>::addNode(Node *node_i, int nn){
int size = node_i->size++;
if(size >= node_i->capacity){
//node_i->nns_inds = static_cast<int*>(realloc(node_i->nns_inds, /*size*2*/ (size + 10)*sizeof(int)));
node_i->nns_inds.resize(size + 10);
node_i->capacity = /*size*2*/ size + 10;
}
node_i->nns_inds[size] = nn;
}
}
_MTF_END_NAMESPACE
//! for NT version of NN
#include "mtf/AM/AppearanceModel.h"
template class mtf::gnn::GNN< mtf::AppearanceModel >;
#ifndef ENABLE_ONLY_NT
//! for standard version of NN
#include "mtf/Macros/register.h"
_REGISTER_AM_TRACKERS(gnn::GNN);
#endif
| [
"asingh1@ualberta.ca"
] | asingh1@ualberta.ca |
6cc341c106c0624f8f9eb21da04159d889b32df0 | a5b1be0f4ad2cb944205a0bd19a28684c4355e0c | /HK/C++/cpp-class-template-specialization.cpp | 139f49ad6eb79e9d392f5da792f3561f7f432aae | [] | no_license | warlockz/CP | 4bf00bf9b89d785ec0b3e146d6e9b29923553d40 | 53e8b05a9622c36e9fd37147b3b03a62c51c0567 | refs/heads/master | 2021-01-19T00:43:17.305693 | 2017-08-02T00:01:47 | 2017-08-02T00:01:47 | 87,202,589 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,516 | cpp | #include <iostream>
using namespace std;
enum class Fruit { apple, orange, pear };
enum class Color { red, green, orange };
template <typename T> struct Traits;
// Define specializations for the Traits class template here.
template <typename T>
struct Traits
{
static string name(int n)
{
return "unknown";
}
};
template<>
struct Traits<Fruit>
{
static string name(int n)
{
string name;
switch(n)
{
case 0 :
name = "apple";
break;
case 1 :
name = "orange";
break;
case 2 :
name = "pear";
break;
default :
name = "unknown";
break;
}
return name;
}
};
template<>
struct Traits<Color>
{
static string name(int n)
{
string name;
switch(n)
{
case 0 :
name = "red";
break;
case 1 :
name = "green";
break;
case 2 :
name = "orange";
break;
default :
name = "unknown";
break;
}
return name;
}
};
int main()
{
int t = 0; std::cin >> t;
for (int i=0; i!=t; ++i) {
int index1; std::cin >> index1;
int index2; std::cin >> index2;
cout << Traits<Color>::name(index1) << " ";
cout << Traits<Fruit>::name(index2) << "\n";
}
} | [
"yogerocks@gmail.com"
] | yogerocks@gmail.com |
b1981b2b04c982c4c6adf787ea8d718674fae4b5 | 5dbbadea06927ec4b8d93c127771783538913540 | /CppPublishSubscribe/PubSubManager.cpp | c982522cdc89cdaa4d82d412375c89e0b32deafe | [
"MIT"
] | permissive | hs750/CppPublishSubscribe | 30e21e9caf4082c85db0064d24c97ff9cf48a58d | 727f76a3f0be804db74e360c96084e5e1a226562 | refs/heads/master | 2021-04-06T20:27:31.287105 | 2016-06-10T14:57:13 | 2016-06-10T14:57:13 | 60,851,060 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 539 | cpp |
#include "PubSubManager.h"
using namespace cps;
void PubSubManager::addSubscriber(Subscriber * subsciber){
subscribers.insert(subsciber);
}
void PubSubManager::broadcastData(PublishableData * data, Publisher * sender){
for(auto sub : subscribers){
bool send = true;
if(Publisher * pubsub = dynamic_cast<Publisher*>(sub)){
if(pubsub == sender){
send = sender->allowPublishLoopback();
}
}
if(send){
sub->receive(data);
}
}
} | [
"contact@harrison-spain.com"
] | contact@harrison-spain.com |
0e1888c5b88e46eaa7dfe5c051006e105691b7e4 | 3cc396f9397706e05f05ed718a4f64fc60eab681 | /include/pause.h | b8c488c454f6e8775e7ef2411f572815828d1a2b | [] | no_license | hasashin/tetris-sdl | 6acd4acccfb6611ee966b9052aad5d9fc29f786d | a6256c210df6ad7f50e46829c6cbd911811e8d42 | refs/heads/master | 2020-03-08T23:58:25.538826 | 2018-05-30T15:37:40 | 2018-05-30T15:37:40 | 128,476,643 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,154 | h | #ifndef TETRIS_SDL_PAUSE_H
#define TETRIS_SDL_PAUSE_H
#include <control.h>
class pause : public object {
void drawPause() {
SDL_Rect pause;
pause.x = 0;
pause.y = 0;
pause.w = global::SCREEN_W;
pause.h = global::SCREEN_H;
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 128);
SDL_RenderFillRect(renderer, &pause);
SDL_Texture *text = global::renderText(renderer, "PAUZA", {255, 255, 255, 255}, "title");
int w, h, x, y;
SDL_QueryTexture(text, nullptr, nullptr, &w, &h);
x = global::SCREEN_W / 2 - w / 2;
y = global::SCREEN_H / 2 - h / 2;
global::drawScaledTexture(x, y, w, h, text, renderer);
SDL_RenderPresent(renderer);
}
void keyboardInputControl(SDL_Scancode scancode) override {
switch (scancode) {
case SDL_SCANCODE_ESCAPE:
global::pause = false;
break;
default:
break;
}
}
public:
explicit pause(SDL_Renderer *renderer_) : object(renderer_) {}
void operator()() {
drawPause();
}
};
#endif //TETRIS_SDL_PAUSE_H
| [
"kp+#yn2XtA"
] | kp+#yn2XtA |
6b86626a94cfa18e60f6b362c7ce72fee4eacefd | adefab1f540aee6a245b250ea660faa618513431 | /contrib/libpoco/Zip/include/Poco/Zip/ZipArchiveInfo.h | 571c7a3799b81996f4360c4bef135dff7c1fbe9e | [
"BSL-1.0",
"Apache-2.0"
] | permissive | SevaCode/ClickHouse | 23b6ba4f3ae9ed62807dcdd8e5d3bae68c8e038b | 08cb8e506b49aef6ae2086be8947f728450c4d73 | refs/heads/master | 2020-06-14T15:16:59.282376 | 2016-11-29T19:28:50 | 2016-11-29T19:28:50 | 75,167,027 | 0 | 0 | NOASSERTION | 2019-03-14T09:46:11 | 2016-11-30T08:29:42 | C++ | UTF-8 | C++ | false | false | 4,875 | h | //
// ZipArchiveInfo.h
//
// $Id: //poco/1.4/Zip/include/Poco/Zip/ZipArchiveInfo.h#1 $
//
// Library: Zip
// Package: Zip
// Module: ZipArchiveInfo
//
// Definition of the ZipArchiveInfo class.
//
// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Zip_ZipArchiveInfo_INCLUDED
#define Zip_ZipArchiveInfo_INCLUDED
#include "Poco/Zip/Zip.h"
#include "Poco/Zip/ZipCommon.h"
#include "Poco/Zip/ZipUtil.h"
namespace Poco {
namespace Zip {
class Zip_API ZipArchiveInfo
/// A ZipArchiveInfo stores central directory info
{
public:
static const char HEADER[ZipCommon::HEADER_SIZE];
ZipArchiveInfo();
/// Default constructor, everything set to zero or empty
ZipArchiveInfo(std::istream& in, bool assumeHeaderRead);
/// Creates the ZipArchiveInfo by parsing the input stream.
/// If assumeHeaderRead is true we assume that the first 4 bytes were already read outside.
~ZipArchiveInfo();
/// Destroys the ZipArchiveInfo.
Poco::UInt16 getDiskNumber() const;
/// Get the number of the disk where this header can be found
Poco::UInt16 getFirstDiskForDirectoryHeader() const;
/// Returns the number of the disk that contains the start of the directory header
Poco::UInt16 getNumberOfEntries() const;
/// Returns the number of entries on this disk
Poco::UInt16 getTotalNumberOfEntries() const;
/// Returns the total number of entries on all disks
Poco::UInt32 getCentralDirectorySize() const;
/// Returns the size of the central directory in bytes
std::streamoff getHeaderOffset() const;
/// Returns the offset of the header in relation to the begin of this disk
const std::string& getZipComment() const;
/// Returns the (optional) Zip Comment
void setZipComment(const std::string& comment);
/// Sets the optional Zip comment.
void setNumberOfEntries(Poco::UInt16 val);
/// Returns the number of entries on this disk
void setTotalNumberOfEntries(Poco::UInt16 val);
/// Returns the total number of entries on all disks
void setCentralDirectorySize(Poco::UInt32 val);
/// Returns the size of the central directory in bytes
void setHeaderOffset(Poco::UInt32 val);
std::string createHeader() const;
/// Creates a header
private:
void parse(std::istream& inp, bool assumeHeaderRead);
Poco::UInt16 getZipCommentSize() const;
private:
enum
{
HEADER_POS = 0,
NUMBEROFTHISDISK_POS = HEADER_POS + ZipCommon::HEADER_SIZE,
NUMBEROFTHISDISK_SIZE = 2,
NUMBEROFCENTRALDIRDISK_POS = NUMBEROFTHISDISK_POS + NUMBEROFTHISDISK_SIZE,
NUMBEROFCENTRALDIRDISK_SIZE = 2,
NUMENTRIESTHISDISK_POS = NUMBEROFCENTRALDIRDISK_POS + NUMBEROFCENTRALDIRDISK_SIZE,
NUMENTRIESTHISDISK_SIZE = 2,
TOTALNUMENTRIES_POS = NUMENTRIESTHISDISK_POS + NUMENTRIESTHISDISK_SIZE,
TOTALNUMENTRIES_SIZE = 2,
CENTRALDIRSIZE_POS = TOTALNUMENTRIES_POS + TOTALNUMENTRIES_SIZE,
CENTRALDIRSIZE_SIZE = 4,
CENTRALDIRSTARTOFFSET_POS = CENTRALDIRSIZE_POS + CENTRALDIRSIZE_SIZE,
CENTRALDIRSTARTOFFSET_SIZE = 4,
ZIPCOMMENT_LENGTH_POS = CENTRALDIRSTARTOFFSET_POS + CENTRALDIRSTARTOFFSET_SIZE,
ZIPCOMMENT_LENGTH_SIZE = 2,
FULLHEADER_SIZE = 22
};
char _rawInfo[FULLHEADER_SIZE];
std::streamoff _startPos;
std::string _comment;
};
inline Poco::UInt16 ZipArchiveInfo::getDiskNumber() const
{
return ZipUtil::get16BitValue(_rawInfo, NUMBEROFTHISDISK_POS);
}
inline Poco::UInt16 ZipArchiveInfo::getFirstDiskForDirectoryHeader() const
{
return ZipUtil::get16BitValue(_rawInfo, NUMBEROFCENTRALDIRDISK_POS);
}
inline Poco::UInt16 ZipArchiveInfo::getNumberOfEntries() const
{
return ZipUtil::get16BitValue(_rawInfo, NUMENTRIESTHISDISK_POS);
}
inline Poco::UInt16 ZipArchiveInfo::getTotalNumberOfEntries() const
{
return ZipUtil::get16BitValue(_rawInfo, TOTALNUMENTRIES_POS);
}
inline Poco::UInt32 ZipArchiveInfo::getCentralDirectorySize() const
{
return ZipUtil::get32BitValue(_rawInfo, CENTRALDIRSIZE_POS);
}
inline std::streamoff ZipArchiveInfo::getHeaderOffset() const
{
return _startPos;
}
inline Poco::UInt16 ZipArchiveInfo::getZipCommentSize() const
{
return ZipUtil::get16BitValue(_rawInfo, ZIPCOMMENT_LENGTH_POS);
}
inline const std::string& ZipArchiveInfo::getZipComment() const
{
return _comment;
}
inline void ZipArchiveInfo::setNumberOfEntries(Poco::UInt16 val)
{
ZipUtil::set16BitValue(val, _rawInfo, NUMENTRIESTHISDISK_POS);
}
inline void ZipArchiveInfo::setTotalNumberOfEntries(Poco::UInt16 val)
{
ZipUtil::set16BitValue(val, _rawInfo, TOTALNUMENTRIES_POS);
}
inline void ZipArchiveInfo::setCentralDirectorySize(Poco::UInt32 val)
{
ZipUtil::set32BitValue(val, _rawInfo, CENTRALDIRSIZE_POS);
}
inline void ZipArchiveInfo::setHeaderOffset(Poco::UInt32 val)
{
ZipUtil::set32BitValue(val, _rawInfo, CENTRALDIRSTARTOFFSET_POS);
}
} } // namespace Poco::Zip
#endif // Zip_ZipArchiveInfo_INCLUDED
| [
"milovidov@yandex-team.ru"
] | milovidov@yandex-team.ru |
a5e2e910b611408e1c8e11ed69c590379c991e85 | 6b40ba32242605cff4be9d06a5ef61c35f4ba743 | /OpenGLTest/main.cpp | a043831a1b618a7af10ccb2daa61bef11ce8764a | [] | no_license | Minebot17/OpenGLTest | 8e9c1c536fa09ce8cf284e5600e103cc748606b7 | f7e16113ef163ac4aee36d7027d2181028dc9d34 | refs/heads/master | 2020-08-15T13:40:43.142110 | 2019-12-21T07:01:51 | 2019-12-21T07:01:51 | 215,352,079 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 25,076 | cpp | #include <cstdio>
#include <cstdlib>
#pragma comment(lib, "glew32.lib")
#pragma comment(lib, "glew32s.lib")
#include <GL/glew.h>
#include <GL/GL.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <GL/freeglut.h>
#include <windows.h>
#include "utils.cpp"
#include <thread>
#include <chrono>
#include <clocale>
using namespace glm;
using namespace std::chrono_literals;
int main() {
setlocale(LC_CTYPE, "rus"); // вызов функции настройки локали
// Инициализируем GLFW
if (!glfwInit()) {
fprintf(stderr, "Ошибка при инициализации GLFW\n");
return -1;
}
glfwWindowHint(GLFW_SAMPLES, 4); // 4x Сглаживание
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // Мы хотим использовать OpenGL 3.3
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // To make MacOS happy; should not be needed
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // Мы не хотим старый OpenGL
// Открыть окно и создать в нем контекст OpenGL
GLFWwindow* window; // (В сопроводительном исходном коде эта переменная является глобальной)
window = glfwCreateWindow(1600, 1200, "Test", nullptr, nullptr);
if (window == nullptr) {
fprintf(stderr, "Невозможно открыть окно GLFW. Если у вас Intel GPU, то он не поддерживает версию 3.3. Попробуйте версию уроков для OpenGL 2.1.n");
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
// Инициализируем GLEW
glewExperimental = true; // Флаг необходим в Core-режиме OpenGL
if (glewInit() != GLEW_OK) {
fprintf(stderr, "Невозможно инициализировать GLEWn");
return -1;
}
int w, h;
glfwGetWindowSize(window, &w, &h);
//glfwSetCursorPos(window, float(w) / 2.0f, float(h) / 2.0f);
//glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
GLuint shadow_framebuffer_id = 0;
glGenFramebuffers(1, &shadow_framebuffer_id);
glBindFramebuffer(GL_FRAMEBUFFER, shadow_framebuffer_id);
// Depth texture. Slower than a depth buffer, but you can sample it later in your shader
GLuint shadow_texture;
glGenTextures(1, &shadow_texture);
glBindTexture(GL_TEXTURE_2D, shadow_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, 4096, 4096, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, shadow_texture, 0);
glDrawBuffer(GL_NONE); // No color buffer is drawn to.
// Always check that our framebuffer is ok
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
printf("Framebuffer isn't ok");
GLuint shadow_map_program_id = load_shaders("shadow_map_vertex.glsl", "shadow_map_fragment.glsl");
GLuint shadow_mvp_location = glGetUniformLocation(shadow_map_program_id, "shadow_mvp");
// The framebuffer, which regroups 0, 1, or more textures, and 0 or 1 depth buffer.
GLuint framebuffer_id = 0;
glGenFramebuffers(1, &framebuffer_id);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id);
// The texture we're going to render to
GLuint rendered_texture;
glGenTextures(1, &rendered_texture);
// "Bind" the newly created texture : all future texture functions will modify this texture
glBindTexture(GL_TEXTURE_2D, rendered_texture);
// Give an empty image to OpenGL ( the last "0" )
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
// Poor filtering. Needed !
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
// The depth buffer
GLuint depth_renderbuffer;
glGenRenderbuffers(1, &depth_renderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, depth_renderbuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, w, h);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_renderbuffer);
// Set "renderedTexture" as our colour attachement #0
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, rendered_texture, 0);
// Set the list of draw buffers.
GLenum DrawBuffers[1] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers(1, DrawBuffers); // "1" is the size of DrawBuffers
// Always check that our framebuffer is ok
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
printf("Framebuffer isn't ok");
// The fullscreen quad's FBO
GLuint quad_vertex_array_id;
glGenVertexArrays(1, &quad_vertex_array_id);
glBindVertexArray(quad_vertex_array_id);
static const GLfloat g_quad_vertex_buffer_data[] = {
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
-1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
1.0f, 1.0f, 0.0f,
};
static const GLfloat g_quad_uv_buffer_data[] = {
0.0f, 0.0f,
1.0f, 0.0f,
0.0f, 1.0f,
0.0f, 1.0f,
1.0f, 0.0f,
1.0f, 1.0f
};
GLuint quad_vertex_buffer;
glGenBuffers(1, &quad_vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, quad_vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data), g_quad_vertex_buffer_data, GL_STATIC_DRAW);
GLuint quad_uv_buffer;
glGenBuffers(1, &quad_uv_buffer);
glBindBuffer(GL_ARRAY_BUFFER, quad_uv_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_uv_buffer_data), g_quad_uv_buffer_data, GL_STATIC_DRAW);
// Create and compile our GLSL program from the shaders
GLuint post_program_id = load_shaders("post_vertex.glsl", "post_fragment.glsl");
GLuint rendered_texture_location = glGetUniformLocation(post_program_id, "rendered_texture");
GLuint post_time_location = glGetUniformLocation(post_program_id, "time");
GLuint post_shadow_texture_location = glGetUniformLocation(post_program_id, "shadow_texture");
GLuint post_gamma_location = glGetUniformLocation(post_program_id, "gamma");
// The framebuffer, which regroups 0, 1, or more textures, and 0 or 1 depth buffer.
int msaa_samples = 8;
GLuint msaa_framebuffer_id = 0;
glGenFramebuffers(1, &msaa_framebuffer_id);
glBindFramebuffer(GL_FRAMEBUFFER, msaa_framebuffer_id);
// The texture we're going to render to
GLuint msaa_rendered_texture;
glGenTextures(1, &msaa_rendered_texture);
// "Bind" the newly created texture : all future texture functions will modify this texture
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, msaa_rendered_texture);
// Give an empty image to OpenGL
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, msaa_samples, GL_RGB, w, h, GL_TRUE);
// Poor filtering. Needed !
glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
// The depth buffer
GLuint msaa_depth_renderbuffer;
glGenRenderbuffers(1, &msaa_depth_renderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, msaa_depth_renderbuffer);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa_samples, GL_DEPTH_COMPONENT, w, h);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, msaa_depth_renderbuffer);
// Set "renderedTexture" as our colour attachement #0
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, msaa_rendered_texture, 0);
// Set the list of draw buffers.
GLenum msaa_DrawBuffers[1] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers(1, msaa_DrawBuffers); // "1" is the size of DrawBuffers
// Always check that our framebuffer is ok
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
printf("Framebuffer isn't ok");
vector<vec3> sky_one_vertices = {
vec3(-1,-1,-1),
vec3(1,-1,-1),
vec3(1,1,-1),
vec3(-1,1,-1),
vec3(-1,-1,1),
vec3(1,-1,1),
vec3(1,1,1),
vec3(-1,1,1),
};
vector<int> sky_indexes = { 2,3,0,0,1,2,2,1,6,1,5,6,4,3,7,4,0,3,4,7,6,6,5,4,3,2,6,7,3,6,5,1,0,4,5,0 };
vector<vec3> sky_vertices;
for (int i = 0; i < sky_indexes.size(); i++)
sky_vertices.push_back(sky_one_vertices[sky_indexes[i]]);
GLuint sky_vao;
glGenVertexArrays(1, &sky_vao);
glBindVertexArray(sky_vao);
GLuint sky_shader_id = load_shaders("sky_vertex.glsl", "sky_fragment.glsl");
GLuint sky_mvp_location = glGetUniformLocation(sky_shader_id, "mvp");
GLuint sky_cubemap_location = glGetUniformLocation(sky_shader_id, "skybox");
GLuint sky_vertex_buffer;
glGenBuffers(1, &sky_vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, sky_vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, sky_vertices.size() * sizeof(glm::vec3), &sky_vertices[0], GL_STATIC_DRAW);
// Создаем VAO
GLuint vertex_array_id;
glGenVertexArrays(1, &vertex_array_id);
glBindVertexArray(vertex_array_id);
std::vector< glm::vec3 > vertices;
std::vector< glm::vec2 > uvs;
std::vector< glm::vec3 > normals;
std::vector<vec3> tangents;
std::vector<vec3> bitangents;
load_obj("C:\\Users\\serpi\\Documents\\CppProjects\\OpenGLTest\\OpenGLTest\\Intergalactic_Spaceship.obj", vertices, uvs, normals);
compute_tangent_basis(vertices, uvs, normals, tangents, bitangents);
GLuint vertex_buffer;
glGenBuffers(1, &vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW);
GLuint uv_buffer;
glGenBuffers(1, &uv_buffer);
glBindBuffer(GL_ARRAY_BUFFER, uv_buffer);
glBufferData(GL_ARRAY_BUFFER, uvs.size() * sizeof(vec2), &uvs[0], GL_STATIC_DRAW);
GLuint normal_buffer;
glGenBuffers(1, &normal_buffer);
glBindBuffer(GL_ARRAY_BUFFER, normal_buffer);
glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(vec3), &normals[0], GL_STATIC_DRAW);
GLuint tangent_buffer;
glGenBuffers(1, &tangent_buffer);
glBindBuffer(GL_ARRAY_BUFFER, tangent_buffer);
glBufferData(GL_ARRAY_BUFFER, tangents.size() * sizeof(glm::vec3), &tangents[0], GL_STATIC_DRAW);
GLuint bitangent_buffer;
glGenBuffers(1, &bitangent_buffer);
glBindBuffer(GL_ARRAY_BUFFER, bitangent_buffer);
glBufferData(GL_ARRAY_BUFFER, bitangents.size() * sizeof(glm::vec3), &bitangents[0], GL_STATIC_DRAW);
// Включим режим отслеживания нажатия клавиш, для проверки ниже
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
// Создать и откомпилировать нашу шейдерную программу
GLuint program_id = load_shaders("vertex_standart.glsl", "fragment_standart.glsl", "geometry_standart.glsl");
// Получить хэндл переменной в шейдере
GLuint matrix_id = glGetUniformLocation(program_id, "mvp");
GLuint model_matrix_id = glGetUniformLocation(program_id, "model");
GLuint view_matrix_id = glGetUniformLocation(program_id, "view");
GLuint mv3x3_id = glGetUniformLocation(program_id, "mv3x3");
GLuint light_color_id = glGetUniformLocation(program_id, "lightColor");
GLuint light_power_id = glGetUniformLocation(program_id, "lightPower");
GLuint light_position_worldspace_id = glGetUniformLocation(program_id, "lightDirection_worldspace");
GLuint depth_bias_mvp_id = glGetUniformLocation(program_id, "depthBiasMVP");
GLuint time_id = glGetUniformLocation(program_id, "time");
GLuint texture_location = glGetUniformLocation(program_id, "textureSampler");
GLuint normal_location = glGetUniformLocation(program_id, "normalSampler");
GLuint specular_location = glGetUniformLocation(program_id, "specularSampler");
GLuint shadow_location = glGetUniformLocation(program_id, "shadowSampler");
// Фрагмент будет выводиться только в том, случае, если он находится ближе к камере, чем предыдущий
glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
GLuint texture_id = load_bmp("space_ship.bmp", true);
GLuint normal_id = load_bmp("space_ship_normals.bmp", false);
GLuint specular_id = load_bmp("space_ship_specular.bmp", false);
vector<std::string> faces {
"sky_neg_x.bmp",
"sky_pos_x.bmp",
"sky_pos_y.bmp",
"sky_neg_y.bmp",
"sky_pos_z.bmp",
"sky_neg_z.bmp"
};
unsigned int cubemap_texture = load_cubemap(faces);
float delta_time = 0;
float last_time = 0;
vec3 position = vec3(-5, 0, 0);
float x_angle = 0;
float y_angle = 0;
const float mouse_speed = 0.04f;
const float fly_speed = 4.0f;
while (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwWindowShouldClose(window) == 0) {
delta_time = float(glfwGetTime()) - last_time;
last_time = float(glfwGetTime());
double dx, dy;
glfwGetWindowSize(window, &w, &h);
glfwGetCursorPos(window, &dx, &dy);
//glfwSetCursorPos(window, float(w)/2.0f, float(h)/2.0f);
dx -= float(w) / 2.0f;
dy -= float(h) / 2.0f;
x_angle += float(dx) * delta_time * mouse_speed;
y_angle += float(-dy) * delta_time * mouse_speed;
vec3 left = vec4(cosf(x_angle - pi<float>()/2.0f), 0, sinf(x_angle - pi<float>() / 2.0f), 1);
vec3 forward = glm::rotate(mat4(1.0f), y_angle, vec3(0, 0, 1)) * vec4(1, 0, 0, 0) * glm::rotate(mat4(1.0f), x_angle, vec3(0, 1, 0));
vec3 up = glm::cross(forward, left);
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
position += fly_speed * forward * delta_time;
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
position += fly_speed * -forward * delta_time;
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
position += fly_speed * left * delta_time;
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
position += fly_speed * -left * delta_time;
if (glfwGetKey(window, GLFW_KEY_C) == GLFW_PRESS)
position += fly_speed * -up * delta_time;
if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
position += fly_speed * up * delta_time;
// Проекционная матрица : 45° поле обзора, 4:3 соотношение сторон, диапазон : 0.1 юнит <-> 100 юнитов
mat4 projection = glm::perspective(radians(75.0f), 4.0f / 3.0f, 0.1f, 100.0f);
// Или, для ортокамеры
mat4 view = glm::lookAt(
vec3(rotate(mat4(1.0f), float(glfwGetTime() / 4.0f), vec3(0.25f, 1, 0)) * vec4(0, 4, 2, 0)), // Камера находится в мировых координатах
vec3(rotate(mat4(1.0f), float(glfwGetTime() / 4.0f), vec3(0.25f, 1, 0)) * vec4(0, 0, -2, 0)),
vec3(rotate(mat4(1.0f), float(glfwGetTime() / 4.0f), vec3(0.25f, 1, 0)) * vec4(0, 0.5f, -0.5f, 0)) // "Голова" находится сверху
);
// Матрица модели : единичная матрица (Модель находится в начале координат)
mat4 model = glm::rotate(mat4(1.0f), float(glfwGetTime() / 4.0f), vec3(0.25f, 1, 0)) * glm::translate(mat4(1.0f), vec3(0, 0, -2)); // Индивидуально для каждой модели
// Итоговая матрица ModelViewProjection, которая является результатом перемножения наших трех матриц
mat4 mvp = projection * view * model; // Помните, что умножение матрицы производиться в обратном порядке
// Передать наши трансформации в текущий шейдер
// Это делается в основном цикле, поскольку каждая модель будет иметь другую MVP-матрицу (как минимум часть M)
vec3 light_color = vec3(1.0f, 1.0f, 1.0f);
vec3 light_position = vec3(0.454f, 0.536f, 0.712f);
vec3 light_direction_worldspace = normalize(light_position);
//vec3 right_light = vec4(sinf(glfwGetTime() - pi<float>() / 2.0f), 0, cosf(glfwGetTime() - pi<float>() / 2.0f), 1);
//vec3 up_light = glm::cross(right_light, light_direction_worldspace);
float light_power = 2.0f;
mat3 mv3x3 = mat3(model * view);
glm::mat4 shadow_projection_matrix = glm::ortho<float>(-10, 10, -10, 10, -5,8);
glm::mat4 shadow_view_matrix = glm::lookAt(light_position, glm::vec3(0, 0, 0), vec3(0, 1, 0));
glm::mat4 shadow_model_matrix = model;
glm::mat4 shadow_mvp = shadow_projection_matrix * shadow_view_matrix * shadow_model_matrix;
const glm::mat4 bias_matrix(
0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0
);
glm::mat4 depth_bias_mvp = bias_matrix * shadow_mvp;
// Render to our framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, shadow_framebuffer_id);
glViewport(0, 0, 4096, 4096); // Render on the whole framebuffer, complete from the lower left corner to the upper righ
glBindVertexArray(vertex_array_id);
// Устанавливаем наш шейдер текущим
glUseProgram(shadow_map_program_id);
// Send our transformation to the currently bound shader,
// in the "MVP" uniform
glUniformMatrix4fv(shadow_mvp_location, 1, GL_FALSE, &shadow_mvp[0][0]);
glClearColor(0.0f, 0.0f, 0.25f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glVertexAttribPointer(
0, // Атрибут 0. Подробнее об этом будет рассказано в части, посвященной шейдерам.
3, // Размер
GL_FLOAT, // Тип
GL_FALSE, // Указывает, что значения не нормализованы
0, // Шаг
(void*)0 // Смещение массива в буфере
);
glDrawArrays(GL_TRIANGLES, 0, vertices.size()); // 12*3 индексов начинающихся с 0. -> 12 треугольников -> 6 граней.
glDisableVertexAttribArray(0);
glBindFramebuffer(GL_FRAMEBUFFER, msaa_framebuffer_id);
glViewport(0, 0, w, h); // Render on the whole framebuffer, complete from the lower left corner to the upper righ
glBindVertexArray(vertex_array_id);
// Устанавливаем наш шейдер текущим
glUseProgram(program_id);
glUniformMatrix4fv(matrix_id, 1, GL_FALSE, &mvp[0][0]);
glUniformMatrix4fv(model_matrix_id, 1, GL_FALSE, &model[0][0]);
glUniformMatrix4fv(view_matrix_id, 1, GL_FALSE, &view[0][0]);
glUniformMatrix4fv(depth_bias_mvp_id, 1, GL_FALSE, &depth_bias_mvp[0][0]);
glUniformMatrix3fv(mv3x3_id, 1, GL_FALSE, &mv3x3[0][0]);
glUniform3f(light_position_worldspace_id, light_direction_worldspace.x, light_direction_worldspace.y, light_direction_worldspace.z);
glUniform3f(light_color_id, light_color.x, light_color.y, light_color.z);
glUniform1f(light_power_id, light_power);
glUniform1f(time_id, glfwGetTime());
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture_id);
glUniform1i(texture_location, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, normal_id);
glUniform1i(normal_location, 1);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, specular_id);
glUniform1i(specular_location, 2);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, shadow_texture);
glUniform1i(shadow_location, 3);
glClearColor(0.0f, 0.0f, 0.25f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
// Указываем, что первым буфером атрибутов будут вершины
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glVertexAttribPointer(
0, // Атрибут 0. Подробнее об этом будет рассказано в части, посвященной шейдерам.
3, // Размер
GL_FLOAT, // Тип
GL_FALSE, // Указывает, что значения не нормализованы
0, // Шаг
(void*)0 // Смещение массива в буфере
);
// Второй буфер атрибутов - цвета
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, uv_buffer);
glVertexAttribPointer(
1, // Атрибут. Здесь необязательно указывать 1, но главное, чтобы это значение совпадало с layout в шейдере..
2, // Размер
GL_FLOAT, // Тип
GL_FALSE, // Нормализован?
0, // Шаг
(void*)0 // Смещение
);
glEnableVertexAttribArray(2);
glBindBuffer(GL_ARRAY_BUFFER, normal_buffer);
glVertexAttribPointer(
2,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*) 0
);
glEnableVertexAttribArray(3);
glBindBuffer(GL_ARRAY_BUFFER, tangent_buffer);
glVertexAttribPointer(
3,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0
);
glEnableVertexAttribArray(4);
glBindBuffer(GL_ARRAY_BUFFER, bitangent_buffer);
glVertexAttribPointer(
4,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0
);
// Вывести треугольник
glDrawArrays(GL_TRIANGLES, 0, vertices.size()); // 12*3 индексов начинающихся с 0. -> 12 треугольников -> 6 граней.
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
glDisableVertexAttribArray(4);
mat4 sky_view = mat4(mat3(view));
mat4 sky_mvp = projection * sky_view;
glDepthMask(GL_FALSE);
glBindVertexArray(sky_vao);
glUseProgram(sky_shader_id);
glUniformMatrix4fv(sky_mvp_location, 1, GL_FALSE, &sky_mvp[0][0]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, cubemap_texture);
glUniform1i(sky_cubemap_location, 0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, sky_vertex_buffer);
glVertexAttribPointer(
0, // Атрибут 0. Подробнее об этом будет рассказано в части, посвященной шейдерам.
3, // Размер
GL_FLOAT, // Тип
GL_FALSE, // Указывает, что значения не нормализованы
0, // Шаг
(void*)0 // Смещение массива в буфере
);
glDrawArrays(GL_TRIANGLES, 0, 36);
glDisableVertexAttribArray(0);
glDepthMask(GL_TRUE);
glBindFramebuffer(GL_READ_FRAMEBUFFER, msaa_framebuffer_id);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer_id);
glBlitFramebuffer(0, 0, w, h, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_NEAREST);
// Render to the screen
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, 0, w, h); // Render on the whole framebuffer, complete from the lower left corner to the upper right
glBindVertexArray(quad_vertex_array_id);
glUseProgram(post_program_id);
glDisable(GL_DEPTH_TEST);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, rendered_texture);
glUniform1i(rendered_texture_location, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, shadow_texture);
glUniform1i(post_shadow_texture_location, 1);
glUniform1f(post_time_location, glfwGetTime());
glUniform1f(post_gamma_location, 1.0f/2.2f);
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, quad_vertex_buffer);
glVertexAttribPointer(
0, // Атрибут 0. Подробнее об этом будет рассказано в части, посвященной шейдерам.
3, // Размер
GL_FLOAT, // Тип
GL_FALSE, // Указывает, что значения не нормализованы
0, // Шаг
(void*)0 // Смещение массива в буфере
);
// Второй буфер атрибутов - цвета
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, quad_uv_buffer);
glVertexAttribPointer(
1, // Атрибут. Здесь необязательно указывать 1, но главное, чтобы это значение совпадало с layout в шейдере..
2, // Размер
GL_FLOAT, // Тип
GL_FALSE, // Нормализован?
0, // Шаг
(void*)0 // Смещение
);
glDrawArrays(GL_TRIANGLES, 0, 6);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
// Сбрасываем буферы
glfwSwapBuffers(window);
glfwPollEvents();
}
} | [
"serpinin@mail.ru"
] | serpinin@mail.ru |
35dc8426c175abdd7322726200c5cb651785acd9 | 5b64156d14f1f985060ce208b35ef6ca8335462f | /libraryManager/categorymanager.cpp | 13f7da026f59a498bcc84e3bd30e93a381a4883d | [] | no_license | mhidoart/library_manager_QT | d46d4efd00840691828386a4975ec538378be6fe | 81d60c99a5cb63b14051b13962c56f027171e0fc | refs/heads/master | 2023-04-05T00:22:45.953909 | 2021-03-19T22:43:50 | 2021-03-19T22:43:50 | 346,046,592 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,681 | cpp | #include "categorymanager.h"
CategoryManager::CategoryManager(QString value)
{
source = value;
f1.setFileName(source);
CategoryNextID = 0;
}
void CategoryManager::addCategory(Category c)
{
if(!isCategoryExist(c)){
categories.push_back(c);
}
}
void CategoryManager::load()
{
qInfo() << ">>>>start loading Categories";
QStringList firstColumn;
QFile f1(source);
f1.open(QIODevice::ReadOnly);
QTextStream s1(&f1);
while (!s1.atEnd()){
QString s=s1.readLine(); // reads line from file
firstColumn.append(s.split(",").first()); // appends first column to list, ',' is separator
qInfo() << "creating instance of Category";
int id = s.split(",")[0].toInt();
QString name = s.split(",")[1];
addCategory(Category( id,name ));
}
f1.close();
qInfo() << ">>>>fin load Categories";
for(std::vector<Category>::iterator it = categories.begin(); it != categories.end(); ++it) {
qInfo() << it->toString();
}
}
void CategoryManager::append_csv(Category c)
{
//QFile data(source);
if(f1.open(QIODevice::ReadWrite | QIODevice::Append)){
QTextStream out(&f1);
out << c.getId() << "," << c.getCategory_name() ;
qInfo() << ">>>> category " + c.toString() + " Added succesfully";
}
else{
qInfo() << "error opning : "+ source;
}
f1.close();
}
void CategoryManager::saveAll()
{
if(f1.open(QIODevice::ReadWrite | QIODevice::Truncate | QIODevice::Text)){
QTextStream out(&f1);
for(std::vector<Category>::iterator it = categories.begin(); it != categories.end(); ++it) {
out << it->getId() << "," << it->getCategory_name() ;
}
}
else{
qInfo() << "error opning : "+ source;
}
f1.close();
}
void CategoryManager::deleteCategory_by_id(int id)
{
qInfo() << "deleting Category with id : " + QString::number(id);
for(std::vector<Category>::iterator it = categories.begin(); it != categories.end(); ++it) {
if( it->getId() == id ){
categories.erase(it);
}
}
saveAll();
}
void CategoryManager::deleteCategory(Category c)
{
deleteCategory_by_id(c.getId());
}
bool CategoryManager::isCategoryExist(Category c)
{
for(std::vector<Category>::iterator it = categories.begin(); it != categories.end(); ++it) {
if( it->getId() == c.getId() ){
return true;
}
}
return false;
}
Category *CategoryManager::getCategoryByName(QString value)
{
for(std::vector<Category>::iterator it = categories.begin(); it != categories.end(); ++it) {
if( it->getCategory_name() == value ){
Category* auth = new Category(it->getId(),it->getCategory_name()) ;
return auth;
}
}
return nullptr;
}
Category *CategoryManager::getCategoryById(int value)
{
for(std::vector<Category>::iterator it = categories.begin(); it != categories.end(); ++it) {
if( it->getId() == value ){
Category* auth = new Category(it->getId(),it->getCategory_name()) ;
return auth;
}
}
return nullptr;
}
void CategoryManager::printData()
{
qInfo() << ">>>> Printing all Category manager data : ";
for(std::vector<Category>::iterator it = categories.begin(); it != categories.end(); ++it) {
qInfo() << it->toString();
}
}
int CategoryManager::getNextId()
{
for(std::vector<Category>::iterator it = categories.begin(); it != categories.end(); ++it) {
if( it->getId() >= CategoryNextID ){
CategoryNextID = it->getId();
}
}
CategoryNextID ++;// the next free id
return CategoryNextID;
}
| [
"mhidoart@gmail.com"
] | mhidoart@gmail.com |
3f747173777ca2167970ce4aa5f8f535df516c5c | f0a26ec6b779e86a62deaf3f405b7a83868bc743 | /Engine/Source/Editor/DetailCustomizations/Private/LightComponentDetails.cpp | 41aa6cc161ee835d33975dc1b4bb2494a5e6395b | [] | no_license | Tigrouzen/UnrealEngine-4 | 0f15a56176439aef787b29d7c80e13bfe5c89237 | f81fe535e53ac69602bb62c5857bcdd6e9a245ed | refs/heads/master | 2021-01-15T13:29:57.883294 | 2014-03-20T15:12:46 | 2014-03-20T15:12:46 | 18,375,899 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,439 | cpp | // Copyright 1998-2014 Epic Games, Inc. All Rights Reserved.
#include "DetailCustomizationsPrivatePCH.h"
#include "LightComponentDetails.h"
#define LOCTEXT_NAMESPACE "LightComponentDetails"
TSharedRef<IDetailCustomization> FLightComponentDetails::MakeInstance()
{
return MakeShareable( new FLightComponentDetails );
}
void FLightComponentDetails::CustomizeDetails( IDetailLayoutBuilder& DetailBuilder )
{
// Mobility property is on the scene component base class not the light component and that is why we have to use USceneComponent::StaticClass
TSharedRef<IPropertyHandle> MobilityHandle = DetailBuilder.GetProperty("Mobility", USceneComponent::StaticClass());
// Set a mobility tooltip specific to lights
MobilityHandle->SetToolTipText(LOCTEXT("LightMobilityTooltip", "Mobility for lights controls what the light is allowed to do at runtime and therefore what rendering methods are used.\n * A movable light uses fully dynamic lighting and anything can change in game, however it has a large performance cost, typically proportional to the light's influence size.\n * A stationary light will only have its shadowing and bounced lighting from static geometry baked by Lightmass, all other lighting will be dynamic. It can change color and intensity in game. \n * A static light is fully baked into lightmaps and therefore has no performance cost, but also can't change in game.").ToString());
IDetailCategoryBuilder& LightCategory = DetailBuilder.EditCategory( "Light", TEXT(""), ECategoryPriority::TypeSpecific );
LightIntensityProperty = DetailBuilder.GetProperty("Intensity", ULightComponentBase::StaticClass());
IESBrightnessTextureProperty = DetailBuilder.GetProperty("IESTexture");
IESBrightnessEnabledProperty = DetailBuilder.GetProperty("bUseIESBrightness");
IESBrightnessScaleProperty = DetailBuilder.GetProperty("IESBrightnessScale");
if( !IESBrightnessEnabledProperty->IsValidHandle() )
{
// Brightness and color should be listed first
LightCategory.AddProperty( LightIntensityProperty );
LightCategory.AddProperty( DetailBuilder.GetProperty("LightColor", ULightComponentBase::StaticClass() ) );
}
else
{
IDetailCategoryBuilder& LightProfilesCategory = DetailBuilder.EditCategory( "Light Profiles", TEXT(""), ECategoryPriority::TypeSpecific );
LightCategory.AddProperty( LightIntensityProperty )
.IsEnabled( TAttribute<bool>( this, &FLightComponentDetails::IsLightBrightnessEnabled ) );
LightCategory.AddProperty( DetailBuilder.GetProperty("LightColor", ULightComponentBase::StaticClass() ) );
LightProfilesCategory.AddProperty( IESBrightnessTextureProperty );
LightProfilesCategory.AddProperty( IESBrightnessEnabledProperty )
.IsEnabled( TAttribute<bool>( this, &FLightComponentDetails::IsUseIESBrightnessEnabled ) );
LightProfilesCategory.AddProperty( IESBrightnessScaleProperty)
.IsEnabled( TAttribute<bool>( this, &FLightComponentDetails::IsIESBrightnessScaleEnabled ) );
}
}
bool FLightComponentDetails::IsLightBrightnessEnabled() const
{
return !IsIESBrightnessScaleEnabled();
}
bool FLightComponentDetails::IsUseIESBrightnessEnabled() const
{
UObject* IESTexture;
IESBrightnessTextureProperty->GetValue(IESTexture);
return (IESTexture != NULL);
}
bool FLightComponentDetails::IsIESBrightnessScaleEnabled() const
{
bool Enabled;
IESBrightnessEnabledProperty->GetValue(Enabled);
return IsUseIESBrightnessEnabled() && Enabled;
}
#undef LOCTEXT_NAMESPACE
| [
"michaellam430@gmail.com"
] | michaellam430@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.